﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of an image object(-array).</summary>
	// Token: 0x02000042 RID: 66
	[Serializable]
	public class HImage : HObject, ISerializable, ICloneable
	{
		/// <summary>Create an uninitialized iconic object</summary>
		// Token: 0x06000662 RID: 1634 RVA: 0x00026126 File Offset: 0x00024326
		public HImage() : base(HObjectBase.UNDEF, false)
		{
		}

		// Token: 0x06000663 RID: 1635 RVA: 0x00026134 File Offset: 0x00024334
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HImage(IntPtr key) : this(key, true)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06000664 RID: 1636 RVA: 0x0002614A File Offset: 0x0002434A
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HImage(IntPtr key, bool copy) : base(key, copy)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06000665 RID: 1637 RVA: 0x00026160 File Offset: 0x00024360
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HImage(HObject obj) : base(obj)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06000666 RID: 1638 RVA: 0x00026175 File Offset: 0x00024375
		private void AssertObjectClass()
		{
			HalconAPI.AssertObjectClass(this.key, "image");
		}

		/// <summary>Returns the iconic object(s) at the specified index</summary>
		// Token: 0x1700004A RID: 74
		public HImage this[HTuple index]
		{
			get
			{
				return this.SelectObj(index);
			}
		}

		// Token: 0x06000668 RID: 1640 RVA: 0x00026190 File Offset: 0x00024390
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static int LoadNew(IntPtr proc, int parIndex, int err, out HImage obj)
		{
			obj = new HImage(HObjectBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		/// <summary>
		///   Create an image from a pointer to the pixels.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		/// <param name="pixelPointer">Pointer to first gray value.</param>
		// Token: 0x06000669 RID: 1641 RVA: 0x000261A8 File Offset: 0x000243A8
		public HImage(string type, int width, int height, IntPtr pixelPointer)
		{
			IntPtr proc = HalconAPI.PreCall(606);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.StoreIP(proc, 3, pixelPointer);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an image with constant gray value.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		// Token: 0x0600066A RID: 1642 RVA: 0x00026210 File Offset: 0x00024410
		public HImage(string type, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(607);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read an image with different file formats.
		///   Modified instance represents: Read image.
		/// </summary>
		/// <param name="fileName">Name of the image to be read. Default: "printer_chip/printer_chip_01"</param>
		// Token: 0x0600066B RID: 1643 RVA: 0x0002626C File Offset: 0x0002446C
		public HImage(HTuple fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1658);
			HalconAPI.Store(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(fileName);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read an image with different file formats.
		///   Modified instance represents: Read image.
		/// </summary>
		/// <param name="fileName">Name of the image to be read. Default: "printer_chip/printer_chip_01"</param>
		// Token: 0x0600066C RID: 1644 RVA: 0x000262C0 File Offset: 0x000244C0
		public HImage(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1658);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x0600066D RID: 1645 RVA: 0x0002630C File Offset: 0x0002450C
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeImage();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x0600066E RID: 1646 RVA: 0x00026344 File Offset: 0x00024544
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HImage(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeImage(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x0600066F RID: 1647 RVA: 0x00026384 File Offset: 0x00024584
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeImage();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x06000670 RID: 1648 RVA: 0x00026398 File Offset: 0x00024598
		public new static HImage Deserialize(Stream stream)
		{
			HImage himage = new HImage();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			himage.DeserializeImage(hserializedItem);
			hserializedItem.Dispose();
			return himage;
		}

		// Token: 0x06000671 RID: 1649 RVA: 0x000263BE File Offset: 0x000245BE
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06000672 RID: 1650 RVA: 0x000263C8 File Offset: 0x000245C8
		public new HImage Clone()
		{
			HSerializedItem hserializedItem = this.SerializeImage();
			HImage himage = new HImage();
			himage.DeserializeImage(hserializedItem);
			hserializedItem.Dispose();
			return himage;
		}

		/// <summary>Inverts an image</summary>
		// Token: 0x06000673 RID: 1651 RVA: 0x000263EE File Offset: 0x000245EE
		public static HImage operator -(HImage image)
		{
			return image.InvertImage();
		}

		/// <summary>Adds two images</summary>
		// Token: 0x06000674 RID: 1652 RVA: 0x000263F6 File Offset: 0x000245F6
		public static HImage operator +(HImage image1, HImage image2)
		{
			return image1.AddImage(image2, 1.0, 0.0);
		}

		/// <summary>Subtracts image2 from image1</summary>
		// Token: 0x06000675 RID: 1653 RVA: 0x00026411 File Offset: 0x00024611
		public static HImage operator -(HImage image1, HImage image2)
		{
			return image1.SubImage(image2, 1.0, 0.0);
		}

		/// <summary>Multiplies two images</summary>
		// Token: 0x06000676 RID: 1654 RVA: 0x0002642C File Offset: 0x0002462C
		public static HImage operator *(HImage image1, HImage image2)
		{
			return image1.MultImage(image2, 1.0, 0.0);
		}

		/// <summary>Adds a constant gray value offset</summary>
		// Token: 0x06000677 RID: 1655 RVA: 0x00026447 File Offset: 0x00024647
		public static HImage operator +(HImage image, double add)
		{
			return image.ScaleImage(1.0, add);
		}

		/// <summary>Adds a constant gray value offset</summary>
		// Token: 0x06000678 RID: 1656 RVA: 0x00026459 File Offset: 0x00024659
		public static HImage operator +(double add, HImage image)
		{
			return image.ScaleImage(1.0, add);
		}

		/// <summary>Subtracts a constant gray value offset</summary>
		// Token: 0x06000679 RID: 1657 RVA: 0x0002646B File Offset: 0x0002466B
		public static HImage operator -(HImage image, double sub)
		{
			return image.ScaleImage(1.0, -sub);
		}

		/// <summary>Scales an image by the specified factor</summary>
		// Token: 0x0600067A RID: 1658 RVA: 0x0002647E File Offset: 0x0002467E
		public static HImage operator *(HImage image, double mult)
		{
			return image.ScaleImage(mult, 0.0);
		}

		/// <summary>Scales an image by the specified factor</summary>
		// Token: 0x0600067B RID: 1659 RVA: 0x00026490 File Offset: 0x00024690
		public static HImage operator *(double mult, HImage image)
		{
			return image.ScaleImage(mult, 0.0);
		}

		/// <summary>Scales an image by the specified divisor</summary>
		// Token: 0x0600067C RID: 1660 RVA: 0x000264A2 File Offset: 0x000246A2
		public static HImage operator /(HImage image, double div)
		{
			return image.ScaleImage(1.0 / div, 0.0);
		}

		/// <summary>Segment image using dynamic threshold</summary>
		// Token: 0x0600067D RID: 1661 RVA: 0x000264BE File Offset: 0x000246BE
		public static HRegion operator >=(HImage image1, HImage image2)
		{
			return image1.DynThreshold(image2, 0.0, "light");
		}

		/// <summary>Segment image using dynamic threshold</summary>
		// Token: 0x0600067E RID: 1662 RVA: 0x000264D5 File Offset: 0x000246D5
		public static HRegion operator <=(HImage image1, HImage image2)
		{
			return image1.DynThreshold(image2, 0.0, "dark");
		}

		/// <summary>Segment image using constant threshold</summary>
		// Token: 0x0600067F RID: 1663 RVA: 0x000264EC File Offset: 0x000246EC
		public static HRegion operator >=(HImage image, double threshold)
		{
			return image.Threshold(threshold, double.MaxValue);
		}

		/// <summary>Segment image using constant threshold</summary>
		// Token: 0x06000680 RID: 1664 RVA: 0x000264FE File Offset: 0x000246FE
		public static HRegion operator <=(HImage image, double threshold)
		{
			return image.Threshold(double.MinValue, threshold);
		}

		/// <summary>Segment image using constant threshold</summary>
		// Token: 0x06000681 RID: 1665 RVA: 0x00026510 File Offset: 0x00024710
		public static HRegion operator >=(double threshold, HImage image)
		{
			return image.Threshold(double.MinValue, threshold);
		}

		/// <summary>Segment image using constant threshold</summary>
		// Token: 0x06000682 RID: 1666 RVA: 0x00026522 File Offset: 0x00024722
		public static HRegion operator <=(double threshold, HImage image)
		{
			return image.Threshold(threshold, double.MaxValue);
		}

		/// <summary>Reduces the domain of an image</summary>
		// Token: 0x06000683 RID: 1667 RVA: 0x00026534 File Offset: 0x00024734
		public static HImage operator &(HImage image, HRegion region)
		{
			return image.ReduceDomain(region);
		}

		/// <summary>Returns the domain of an image</summary>
		// Token: 0x06000684 RID: 1668 RVA: 0x0002653D File Offset: 0x0002473D
		public static implicit operator HRegion(HImage image)
		{
			return image.GetDomain();
		}

		/// <summary>
		///   Image restoration by Wiener filtering.
		///   Instance represents: Corrupted image.
		/// </summary>
		/// <param name="psf">impulse response (PSF) of degradation (in spatial domain).</param>
		/// <param name="noiseRegion">Region for noise estimation.</param>
		/// <param name="maskWidth">Width of filter mask. Default: 3</param>
		/// <param name="maskHeight">Height of filter mask. Default: 3</param>
		/// <returns>Restored image.</returns>
		// Token: 0x06000685 RID: 1669 RVA: 0x00026548 File Offset: 0x00024748
		public HImage WienerFilterNi(HImage psf, HRegion noiseRegion, int maskWidth, int maskHeight)
		{
			IntPtr proc = HalconAPI.PreCall(75);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, psf);
			HalconAPI.Store(proc, 3, noiseRegion);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(psf);
			GC.KeepAlive(noiseRegion);
			return result;
		}

		/// <summary>
		///   Image restoration by Wiener filtering.
		///   Instance represents: Corrupted image.
		/// </summary>
		/// <param name="psf">impulse response (PSF) of degradation (in spatial domain).</param>
		/// <param name="filteredImage">Smoothed version of corrupted image.</param>
		/// <returns>Restored image.</returns>
		// Token: 0x06000686 RID: 1670 RVA: 0x000265BC File Offset: 0x000247BC
		public HImage WienerFilter(HImage psf, HImage filteredImage)
		{
			IntPtr proc = HalconAPI.PreCall(76);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, psf);
			HalconAPI.Store(proc, 3, filteredImage);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(psf);
			GC.KeepAlive(filteredImage);
			return result;
		}

		/// <summary>
		///   Generate an impulse response of a (linearly) motion blurring.
		///   Modified instance represents: Impulse response of motion-blur.
		/// </summary>
		/// <param name="PSFwidth">Width of impulse response image. Default: 256</param>
		/// <param name="PSFheight">Height of impulse response image. Default: 256</param>
		/// <param name="blurring">Degree of motion-blur. Default: 20.0</param>
		/// <param name="angle">Angle between direction of motion and x-axis (anticlockwise). Default: 0</param>
		/// <param name="type">PSF prototype resp. type of motion. Default: 3</param>
		// Token: 0x06000687 RID: 1671 RVA: 0x00026620 File Offset: 0x00024820
		public void GenPsfMotion(int PSFwidth, int PSFheight, double blurring, int angle, int type)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(77);
			HalconAPI.StoreI(proc, 0, PSFwidth);
			HalconAPI.StoreI(proc, 1, PSFheight);
			HalconAPI.StoreD(proc, 2, blurring);
			HalconAPI.StoreI(proc, 3, angle);
			HalconAPI.StoreI(proc, 4, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Simulation of (linearly) motion blur.
		///   Instance represents: image to be blurred.
		/// </summary>
		/// <param name="blurring">extent of blurring. Default: 20.0</param>
		/// <param name="angle">Angle between direction of motion and x-axis (anticlockwise). Default: 0</param>
		/// <param name="type">impulse response of motion blur. Default: 3</param>
		/// <returns>motion blurred image.</returns>
		// Token: 0x06000688 RID: 1672 RVA: 0x0002668C File Offset: 0x0002488C
		public HImage SimulateMotion(double blurring, int angle, int type)
		{
			IntPtr proc = HalconAPI.PreCall(78);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, blurring);
			HalconAPI.StoreI(proc, 1, angle);
			HalconAPI.StoreI(proc, 2, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Generate an impulse response of an uniform out-of-focus blurring.
		///   Modified instance represents: Impulse response of uniform out-of-focus blurring.
		/// </summary>
		/// <param name="PSFwidth">Width of result image. Default: 256</param>
		/// <param name="PSFheight">Height of result image. Default: 256</param>
		/// <param name="blurring">Degree of Blurring. Default: 5.0</param>
		// Token: 0x06000689 RID: 1673 RVA: 0x000266EC File Offset: 0x000248EC
		public void GenPsfDefocus(int PSFwidth, int PSFheight, double blurring)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(79);
			HalconAPI.StoreI(proc, 0, PSFwidth);
			HalconAPI.StoreI(proc, 1, PSFheight);
			HalconAPI.StoreD(proc, 2, blurring);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Simulate an uniform out-of-focus blurring of an image.
		///   Instance represents: Image to blur.
		/// </summary>
		/// <param name="blurring">Degree of blurring. Default: 5.0</param>
		/// <returns>Blurred image.</returns>
		// Token: 0x0600068A RID: 1674 RVA: 0x00026748 File Offset: 0x00024948
		public HImage SimulateDefocus(double blurring)
		{
			IntPtr proc = HalconAPI.PreCall(80);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, blurring);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compare an image to a variation model.
		///   Instance represents: Image of the object to be compared.
		/// </summary>
		/// <param name="modelID">ID of the variation model.</param>
		/// <param name="mode">Method used for comparing the variation model. Default: "absolute"</param>
		/// <returns>Region containing the points that differ substantially from the model.</returns>
		// Token: 0x0600068B RID: 1675 RVA: 0x00026798 File Offset: 0x00024998
		public HRegion CompareExtVariationModel(HVariationModel modelID, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(87);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Compare an image to a variation model.
		///   Instance represents: Image of the object to be compared.
		/// </summary>
		/// <param name="modelID">ID of the variation model.</param>
		/// <returns>Region containing the points that differ substantially from the model.</returns>
		// Token: 0x0600068C RID: 1676 RVA: 0x000267F4 File Offset: 0x000249F4
		public HRegion CompareVariationModel(HVariationModel modelID)
		{
			IntPtr proc = HalconAPI.PreCall(88);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Train a variation model.
		///   Instance represents: Images of the object to be trained.
		/// </summary>
		/// <param name="modelID">ID of the variation model.</param>
		// Token: 0x0600068D RID: 1677 RVA: 0x00026848 File Offset: 0x00024A48
		public void TrainVariationModel(HVariationModel modelID)
		{
			IntPtr proc = HalconAPI.PreCall(91);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Compute a projective transformation matrix and the radial distortion coefficient between two images by finding correspondences between points based on known approximations of the projective transformation matrix and the radial distortion coefficient.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="homMat2DGuide">Approximation of the homogeneous projective transformation matrix between the two images.</param>
		/// <param name="kappaGuide">Approximation of the radial distortion coefficient in the two images.</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed homogeneous projective transformation matrix.</returns>
		// Token: 0x0600068E RID: 1678 RVA: 0x00026888 File Offset: 0x00024A88
		public HHomMat2D ProjMatchPointsDistortionRansacGuided(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, HHomMat2D homMat2DGuide, double kappaGuide, double distanceTolerance, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(256);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.Store(proc, 6, homMat2DGuide);
			HalconAPI.StoreD(proc, 7, kappaGuide);
			HalconAPI.StoreD(proc, 8, distanceTolerance);
			HalconAPI.Store(proc, 9, matchThreshold);
			HalconAPI.StoreS(proc, 10, estimationMethod);
			HalconAPI.Store(proc, 11, distanceThreshold);
			HalconAPI.StoreI(proc, 12, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(homMat2DGuide);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix and the radial distortion coefficient between two images by finding correspondences between points based on known approximations of the projective transformation matrix and the radial distortion coefficient.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="homMat2DGuide">Approximation of the homogeneous projective transformation matrix between the two images.</param>
		/// <param name="kappaGuide">Approximation of the radial distortion coefficient in the two images.</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed homogeneous projective transformation matrix.</returns>
		// Token: 0x0600068F RID: 1679 RVA: 0x000269DC File Offset: 0x00024BDC
		public HHomMat2D ProjMatchPointsDistortionRansacGuided(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, HHomMat2D homMat2DGuide, double kappaGuide, double distanceTolerance, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(256);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.Store(proc, 6, homMat2DGuide);
			HalconAPI.StoreD(proc, 7, kappaGuide);
			HalconAPI.StoreD(proc, 8, distanceTolerance);
			HalconAPI.StoreI(proc, 9, matchThreshold);
			HalconAPI.StoreS(proc, 10, estimationMethod);
			HalconAPI.StoreD(proc, 11, distanceThreshold);
			HalconAPI.StoreI(proc, 12, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(homMat2DGuide);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images and the radial distortion coefficient by automatically finding correspondences between points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for the transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed homogeneous projective transformation matrix.</returns>
		// Token: 0x06000690 RID: 1680 RVA: 0x00026B24 File Offset: 0x00024D24
		public HHomMat2D ProjMatchPointsDistortionRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(257);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images and the radial distortion coefficient by automatically finding correspondences between points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for the transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed homogeneous projective transformation matrix.</returns>
		// Token: 0x06000691 RID: 1681 RVA: 0x00026C84 File Offset: 0x00024E84
		public HHomMat2D ProjMatchPointsDistortionRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(257);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points based on a known approximation of the projective transformation matrix.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="homMat2DGuide">Approximation of the Homogeneous projective transformation matrix between the two images.</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x06000692 RID: 1682 RVA: 0x00026DD0 File Offset: 0x00024FD0
		public HHomMat2D ProjMatchPointsRansacGuided(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, HHomMat2D homMat2DGuide, double distanceTolerance, HTuple matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(258);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.Store(proc, 6, homMat2DGuide);
			HalconAPI.StoreD(proc, 7, distanceTolerance);
			HalconAPI.Store(proc, 8, matchThreshold);
			HalconAPI.StoreS(proc, 9, estimationMethod);
			HalconAPI.StoreD(proc, 10, distanceThreshold);
			HalconAPI.StoreI(proc, 11, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(homMat2DGuide);
			HalconAPI.UnpinTuple(matchThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points based on a known approximation of the projective transformation matrix.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="homMat2DGuide">Approximation of the Homogeneous projective transformation matrix between the two images.</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x06000693 RID: 1683 RVA: 0x00026EF0 File Offset: 0x000250F0
		public HHomMat2D ProjMatchPointsRansacGuided(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, HHomMat2D homMat2DGuide, double distanceTolerance, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(258);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.Store(proc, 6, homMat2DGuide);
			HalconAPI.StoreD(proc, 7, distanceTolerance);
			HalconAPI.StoreI(proc, 8, matchThreshold);
			HalconAPI.StoreS(proc, 9, estimationMethod);
			HalconAPI.StoreD(proc, 10, distanceThreshold);
			HalconAPI.StoreI(proc, 11, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(homMat2DGuide);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 256</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 256</param>
		/// <param name="rotation">Range of rotation angles. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x06000694 RID: 1684 RVA: 0x00027008 File Offset: 0x00025208
		public HHomMat2D ProjMatchPointsRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(259);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 256</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 256</param>
		/// <param name="rotation">Range of rotation angles. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x06000695 RID: 1685 RVA: 0x0002713C File Offset: 0x0002533C
		public HHomMat2D ProjMatchPointsRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(259);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Receive an image over a socket connection.
		///   Modified instance represents: Received image.
		/// </summary>
		/// <param name="socket">Socket number.</param>
		// Token: 0x06000696 RID: 1686 RVA: 0x00027260 File Offset: 0x00025460
		public void ReceiveImage(HSocket socket)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(325);
			HalconAPI.Store(proc, 0, socket);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(socket);
		}

		/// <summary>
		///   Send an image over a socket connection.
		///   Instance represents: Image to be sent.
		/// </summary>
		/// <param name="socket">Socket number.</param>
		// Token: 0x06000697 RID: 1687 RVA: 0x000272B4 File Offset: 0x000254B4
		public void SendImage(HSocket socket)
		{
			IntPtr proc = HalconAPI.PreCall(326);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, socket);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(socket);
		}

		/// <summary>
		///   Compute the distance values for a rectified stereo image pair using multi-scanline optimization.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity.</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Point transformation from the rectified camera 2 to the rectified camera 1.</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: -30</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="surfaceSmoothing">Smoothing of surfaces. Default: 50</param>
		/// <param name="edgeSmoothing">Smoothing of edges. Default: 50</param>
		/// <param name="genParamName">Parameter name(s) for the multi-scanline algorithm. Default: []</param>
		/// <param name="genParamValue">Parameter value(s) for the multi-scanline algorithm. Default: []</param>
		/// <returns>Distance image.</returns>
		// Token: 0x06000698 RID: 1688 RVA: 0x000272F8 File Offset: 0x000254F8
		public HImage BinocularDistanceMs(HImage imageRect2, out HImage score, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect, int minDisparity, int maxDisparity, int surfaceSmoothing, int edgeSmoothing, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(346);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.Store(proc, 0, camParamRect1);
			HalconAPI.Store(proc, 1, camParamRect2);
			HalconAPI.Store(proc, 2, relPoseRect);
			HalconAPI.StoreI(proc, 3, minDisparity);
			HalconAPI.StoreI(proc, 4, maxDisparity);
			HalconAPI.StoreI(proc, 5, surfaceSmoothing);
			HalconAPI.StoreI(proc, 6, edgeSmoothing);
			HalconAPI.Store(proc, 7, genParamName);
			HalconAPI.Store(proc, 8, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the distance values for a rectified stereo image pair using multi-scanline optimization.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity.</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Point transformation from the rectified camera 2 to the rectified camera 1.</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: -30</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="surfaceSmoothing">Smoothing of surfaces. Default: 50</param>
		/// <param name="edgeSmoothing">Smoothing of edges. Default: 50</param>
		/// <param name="genParamName">Parameter name(s) for the multi-scanline algorithm. Default: []</param>
		/// <param name="genParamValue">Parameter value(s) for the multi-scanline algorithm. Default: []</param>
		/// <returns>Distance image.</returns>
		// Token: 0x06000699 RID: 1689 RVA: 0x000273F0 File Offset: 0x000255F0
		public HImage BinocularDistanceMs(HImage imageRect2, out HImage score, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect, int minDisparity, int maxDisparity, int surfaceSmoothing, int edgeSmoothing, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(346);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.Store(proc, 0, camParamRect1);
			HalconAPI.Store(proc, 1, camParamRect2);
			HalconAPI.Store(proc, 2, relPoseRect);
			HalconAPI.StoreI(proc, 3, minDisparity);
			HalconAPI.StoreI(proc, 4, maxDisparity);
			HalconAPI.StoreI(proc, 5, surfaceSmoothing);
			HalconAPI.StoreI(proc, 6, edgeSmoothing);
			HalconAPI.StoreS(proc, 7, genParamName);
			HalconAPI.StoreS(proc, 8, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the disparities of a rectified stereo image pair using multi-scanline optimization.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity.</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: -30</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="surfaceSmoothing">Smoothing of surfaces. Default: 50</param>
		/// <param name="edgeSmoothing">Smoothing of edges. Default: 50</param>
		/// <param name="genParamName">Parameter name(s) for the multi-scanline algorithm. Default: []</param>
		/// <param name="genParamValue">Parameter value(s) for the multi-scanline algorithm. Default: []</param>
		/// <returns>Disparity map.</returns>
		// Token: 0x0600069A RID: 1690 RVA: 0x000274DC File Offset: 0x000256DC
		public HImage BinocularDisparityMs(HImage imageRect2, out HImage score, int minDisparity, int maxDisparity, int surfaceSmoothing, int edgeSmoothing, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(347);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.StoreI(proc, 0, minDisparity);
			HalconAPI.StoreI(proc, 1, maxDisparity);
			HalconAPI.StoreI(proc, 2, surfaceSmoothing);
			HalconAPI.StoreI(proc, 3, edgeSmoothing);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the disparities of a rectified stereo image pair using multi-scanline optimization.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity.</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: -30</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="surfaceSmoothing">Smoothing of surfaces. Default: 50</param>
		/// <param name="edgeSmoothing">Smoothing of edges. Default: 50</param>
		/// <param name="genParamName">Parameter name(s) for the multi-scanline algorithm. Default: []</param>
		/// <param name="genParamValue">Parameter value(s) for the multi-scanline algorithm. Default: []</param>
		/// <returns>Disparity map.</returns>
		// Token: 0x0600069B RID: 1691 RVA: 0x00027588 File Offset: 0x00025788
		public HImage BinocularDisparityMs(HImage imageRect2, out HImage score, int minDisparity, int maxDisparity, int surfaceSmoothing, int edgeSmoothing, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(347);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.StoreI(proc, 0, minDisparity);
			HalconAPI.StoreI(proc, 1, maxDisparity);
			HalconAPI.StoreI(proc, 2, surfaceSmoothing);
			HalconAPI.StoreI(proc, 3, edgeSmoothing);
			HalconAPI.StoreS(proc, 4, genParamName);
			HalconAPI.StoreS(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the distance values for a rectified stereo image pair using multigrid methods.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity if CalculateScore is set to 'true'.</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Point transformation from the rectified camera 2 to the rectified camera 1.</param>
		/// <param name="grayConstancy">Weight of the gray value constancy in the data term. Default: 1.0</param>
		/// <param name="gradientConstancy">Weight of the gradient constancy in the data term. Default: 30.0</param>
		/// <param name="smoothness">Weight of the smoothness term in relation to the data term. Default: 5.0</param>
		/// <param name="initialGuess">Initial guess of the disparity. Default: 0.0</param>
		/// <param name="calculateScore">Should the quality measure be returned in Score? Default: "false"</param>
		/// <param name="MGParamName">Parameter name(s) for the multigrid algorithm. Default: "default_parameters"</param>
		/// <param name="MGParamValue">Parameter value(s) for the multigrid algorithm. Default: "fast_accurate"</param>
		/// <returns>Distance image.</returns>
		// Token: 0x0600069C RID: 1692 RVA: 0x00027628 File Offset: 0x00025828
		public HImage BinocularDistanceMg(HImage imageRect2, out HImage score, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect, double grayConstancy, double gradientConstancy, double smoothness, double initialGuess, string calculateScore, HTuple MGParamName, HTuple MGParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(348);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.Store(proc, 0, camParamRect1);
			HalconAPI.Store(proc, 1, camParamRect2);
			HalconAPI.Store(proc, 2, relPoseRect);
			HalconAPI.StoreD(proc, 3, grayConstancy);
			HalconAPI.StoreD(proc, 4, gradientConstancy);
			HalconAPI.StoreD(proc, 5, smoothness);
			HalconAPI.StoreD(proc, 6, initialGuess);
			HalconAPI.StoreS(proc, 7, calculateScore);
			HalconAPI.Store(proc, 8, MGParamName);
			HalconAPI.Store(proc, 9, MGParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HalconAPI.UnpinTuple(MGParamName);
			HalconAPI.UnpinTuple(MGParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the distance values for a rectified stereo image pair using multigrid methods.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity if CalculateScore is set to 'true'.</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Point transformation from the rectified camera 2 to the rectified camera 1.</param>
		/// <param name="grayConstancy">Weight of the gray value constancy in the data term. Default: 1.0</param>
		/// <param name="gradientConstancy">Weight of the gradient constancy in the data term. Default: 30.0</param>
		/// <param name="smoothness">Weight of the smoothness term in relation to the data term. Default: 5.0</param>
		/// <param name="initialGuess">Initial guess of the disparity. Default: 0.0</param>
		/// <param name="calculateScore">Should the quality measure be returned in Score? Default: "false"</param>
		/// <param name="MGParamName">Parameter name(s) for the multigrid algorithm. Default: "default_parameters"</param>
		/// <param name="MGParamValue">Parameter value(s) for the multigrid algorithm. Default: "fast_accurate"</param>
		/// <returns>Distance image.</returns>
		// Token: 0x0600069D RID: 1693 RVA: 0x0002772C File Offset: 0x0002592C
		public HImage BinocularDistanceMg(HImage imageRect2, out HImage score, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect, double grayConstancy, double gradientConstancy, double smoothness, double initialGuess, string calculateScore, string MGParamName, string MGParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(348);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.Store(proc, 0, camParamRect1);
			HalconAPI.Store(proc, 1, camParamRect2);
			HalconAPI.Store(proc, 2, relPoseRect);
			HalconAPI.StoreD(proc, 3, grayConstancy);
			HalconAPI.StoreD(proc, 4, gradientConstancy);
			HalconAPI.StoreD(proc, 5, smoothness);
			HalconAPI.StoreD(proc, 6, initialGuess);
			HalconAPI.StoreS(proc, 7, calculateScore);
			HalconAPI.StoreS(proc, 8, MGParamName);
			HalconAPI.StoreS(proc, 9, MGParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the disparities of a rectified stereo image pair using multigrid methods.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity if CalculateScore is set to 'true'.</param>
		/// <param name="grayConstancy">Weight of the gray value constancy in the data term. Default: 1.0</param>
		/// <param name="gradientConstancy">Weight of the gradient constancy in the data term. Default: 30.0</param>
		/// <param name="smoothness">Weight of the smoothness term in relation to the data term. Default: 5.0</param>
		/// <param name="initialGuess">Initial guess of the disparity. Default: 0.0</param>
		/// <param name="calculateScore">Should the quality measure should be returned in Score? Default: "false"</param>
		/// <param name="MGParamName">Parameter name(s) for the multigrid algorithm. Default: "default_parameters"</param>
		/// <param name="MGParamValue">Parameter value(s) for the multigrid algorithm. Default: "fast_accurate"</param>
		/// <returns>Disparity map.</returns>
		// Token: 0x0600069E RID: 1694 RVA: 0x00027820 File Offset: 0x00025A20
		public HImage BinocularDisparityMg(HImage imageRect2, out HImage score, double grayConstancy, double gradientConstancy, double smoothness, double initialGuess, string calculateScore, HTuple MGParamName, HTuple MGParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(349);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.StoreD(proc, 0, grayConstancy);
			HalconAPI.StoreD(proc, 1, gradientConstancy);
			HalconAPI.StoreD(proc, 2, smoothness);
			HalconAPI.StoreD(proc, 3, initialGuess);
			HalconAPI.StoreS(proc, 4, calculateScore);
			HalconAPI.Store(proc, 5, MGParamName);
			HalconAPI.Store(proc, 6, MGParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(MGParamName);
			HalconAPI.UnpinTuple(MGParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the disparities of a rectified stereo image pair using multigrid methods.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Score of the calculated disparity if CalculateScore is set to 'true'.</param>
		/// <param name="grayConstancy">Weight of the gray value constancy in the data term. Default: 1.0</param>
		/// <param name="gradientConstancy">Weight of the gradient constancy in the data term. Default: 30.0</param>
		/// <param name="smoothness">Weight of the smoothness term in relation to the data term. Default: 5.0</param>
		/// <param name="initialGuess">Initial guess of the disparity. Default: 0.0</param>
		/// <param name="calculateScore">Should the quality measure should be returned in Score? Default: "false"</param>
		/// <param name="MGParamName">Parameter name(s) for the multigrid algorithm. Default: "default_parameters"</param>
		/// <param name="MGParamValue">Parameter value(s) for the multigrid algorithm. Default: "fast_accurate"</param>
		/// <returns>Disparity map.</returns>
		// Token: 0x0600069F RID: 1695 RVA: 0x000278D4 File Offset: 0x00025AD4
		public HImage BinocularDisparityMg(HImage imageRect2, out HImage score, double grayConstancy, double gradientConstancy, double smoothness, double initialGuess, string calculateScore, string MGParamName, string MGParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(349);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.StoreD(proc, 0, grayConstancy);
			HalconAPI.StoreD(proc, 1, gradientConstancy);
			HalconAPI.StoreD(proc, 2, smoothness);
			HalconAPI.StoreD(proc, 3, initialGuess);
			HalconAPI.StoreS(proc, 4, calculateScore);
			HalconAPI.StoreS(proc, 5, MGParamName);
			HalconAPI.StoreS(proc, 6, MGParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the projective rectification of weakly calibrated binocular stereo images.
		///   Modified instance represents: Image coding the rectification of the 1. image.
		/// </summary>
		/// <param name="FMatrix">Fundamental matrix.</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix. Default: []</param>
		/// <param name="width1">Width of the 1. image. Default: 512</param>
		/// <param name="height1">Height of the 1. image. Default: 512</param>
		/// <param name="width2">Width of the 2. image. Default: 512</param>
		/// <param name="height2">Height of the 2. image. Default: 512</param>
		/// <param name="subSampling">Subsampling factor. Default: 1</param>
		/// <param name="mapping">Type of mapping. Default: "no_map"</param>
		/// <param name="covFMatRect">9x9 covariance matrix of the rectified fundamental matrix.</param>
		/// <param name="h1">Projective transformation of the 1. image.</param>
		/// <param name="h2">Projective transformation of the 2. image.</param>
		/// <returns>Image coding the rectification of the 2. image.</returns>
		// Token: 0x060006A0 RID: 1696 RVA: 0x0002797C File Offset: 0x00025B7C
		public HImage GenBinocularProjRectification(HHomMat2D FMatrix, HTuple covFMat, int width1, int height1, int width2, int height2, HTuple subSampling, string mapping, out HTuple covFMatRect, out HHomMat2D h1, out HHomMat2D h2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(351);
			HalconAPI.Store(proc, 0, FMatrix);
			HalconAPI.Store(proc, 1, covFMat);
			HalconAPI.StoreI(proc, 2, width1);
			HalconAPI.StoreI(proc, 3, height1);
			HalconAPI.StoreI(proc, 4, width2);
			HalconAPI.StoreI(proc, 5, height2);
			HalconAPI.Store(proc, 6, subSampling);
			HalconAPI.StoreS(proc, 7, mapping);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(FMatrix);
			HalconAPI.UnpinTuple(covFMat);
			HalconAPI.UnpinTuple(subSampling);
			num = base.Load(proc, 1, num);
			HImage result;
			num = HImage.LoadNew(proc, 2, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out covFMatRect);
			num = HHomMat2D.LoadNew(proc, 1, num, out h1);
			num = HHomMat2D.LoadNew(proc, 2, num, out h2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the projective rectification of weakly calibrated binocular stereo images.
		///   Modified instance represents: Image coding the rectification of the 1. image.
		/// </summary>
		/// <param name="FMatrix">Fundamental matrix.</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix. Default: []</param>
		/// <param name="width1">Width of the 1. image. Default: 512</param>
		/// <param name="height1">Height of the 1. image. Default: 512</param>
		/// <param name="width2">Width of the 2. image. Default: 512</param>
		/// <param name="height2">Height of the 2. image. Default: 512</param>
		/// <param name="subSampling">Subsampling factor. Default: 1</param>
		/// <param name="mapping">Type of mapping. Default: "no_map"</param>
		/// <param name="covFMatRect">9x9 covariance matrix of the rectified fundamental matrix.</param>
		/// <param name="h1">Projective transformation of the 1. image.</param>
		/// <param name="h2">Projective transformation of the 2. image.</param>
		/// <returns>Image coding the rectification of the 2. image.</returns>
		// Token: 0x060006A1 RID: 1697 RVA: 0x00027A70 File Offset: 0x00025C70
		public HImage GenBinocularProjRectification(HHomMat2D FMatrix, HTuple covFMat, int width1, int height1, int width2, int height2, int subSampling, string mapping, out HTuple covFMatRect, out HHomMat2D h1, out HHomMat2D h2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(351);
			HalconAPI.Store(proc, 0, FMatrix);
			HalconAPI.Store(proc, 1, covFMat);
			HalconAPI.StoreI(proc, 2, width1);
			HalconAPI.StoreI(proc, 3, height1);
			HalconAPI.StoreI(proc, 4, width2);
			HalconAPI.StoreI(proc, 5, height2);
			HalconAPI.StoreI(proc, 6, subSampling);
			HalconAPI.StoreS(proc, 7, mapping);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(FMatrix);
			HalconAPI.UnpinTuple(covFMat);
			num = base.Load(proc, 1, num);
			HImage result;
			num = HImage.LoadNew(proc, 2, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out covFMatRect);
			num = HHomMat2D.LoadNew(proc, 1, num, out h1);
			num = HHomMat2D.LoadNew(proc, 2, num, out h2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix and the radial distortion coefficient for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed fundamental matrix.</returns>
		// Token: 0x060006A2 RID: 1698 RVA: 0x00027B60 File Offset: 0x00025D60
		public HHomMat2D MatchFundamentalMatrixDistortionRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(358);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix and the radial distortion coefficient for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed fundamental matrix.</returns>
		// Token: 0x060006A3 RID: 1699 RVA: 0x00027CC0 File Offset: 0x00025EC0
		public HHomMat2D MatchFundamentalMatrixDistortionRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(358);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the relative orientation between two cameras by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="camPar1">Parameters of the 1st camera.</param>
		/// <param name="camPar2">Parameters of the 2nd camera.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the relative pose and for special pose types. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covRelPose">6x6 covariance matrix of the relative orientation.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed relative orientation of the cameras (3D pose).</returns>
		// Token: 0x060006A4 RID: 1700 RVA: 0x00027E0C File Offset: 0x0002600C
		public HPose MatchRelPoseRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HCamPar camPar1, HCamPar camPar2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out HTuple covRelPose, out HTuple error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(359);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, camPar1);
			HalconAPI.Store(proc, 5, camPar2);
			HalconAPI.StoreS(proc, 6, grayMatchMethod);
			HalconAPI.StoreI(proc, 7, maskSize);
			HalconAPI.StoreI(proc, 8, rowMove);
			HalconAPI.StoreI(proc, 9, colMove);
			HalconAPI.StoreI(proc, 10, rowTolerance);
			HalconAPI.StoreI(proc, 11, colTolerance);
			HalconAPI.Store(proc, 12, rotation);
			HalconAPI.Store(proc, 13, matchThreshold);
			HalconAPI.StoreS(proc, 14, estimationMethod);
			HalconAPI.Store(proc, 15, distanceThreshold);
			HalconAPI.StoreI(proc, 16, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(camPar1);
			HalconAPI.UnpinTuple(camPar2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covRelPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the relative orientation between two cameras by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="camPar1">Parameters of the 1st camera.</param>
		/// <param name="camPar2">Parameters of the 2nd camera.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the relative pose and for special pose types. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covRelPose">6x6 covariance matrix of the relative orientation.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed relative orientation of the cameras (3D pose).</returns>
		// Token: 0x060006A5 RID: 1701 RVA: 0x00027FA4 File Offset: 0x000261A4
		public HPose MatchRelPoseRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HCamPar camPar1, HCamPar camPar2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple covRelPose, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(359);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, camPar1);
			HalconAPI.Store(proc, 5, camPar2);
			HalconAPI.StoreS(proc, 6, grayMatchMethod);
			HalconAPI.StoreI(proc, 7, maskSize);
			HalconAPI.StoreI(proc, 8, rowMove);
			HalconAPI.StoreI(proc, 9, colMove);
			HalconAPI.StoreI(proc, 10, rowTolerance);
			HalconAPI.StoreI(proc, 11, colTolerance);
			HalconAPI.StoreD(proc, 12, rotation);
			HalconAPI.StoreI(proc, 13, matchThreshold);
			HalconAPI.StoreS(proc, 14, estimationMethod);
			HalconAPI.StoreD(proc, 15, distanceThreshold);
			HalconAPI.StoreI(proc, 16, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(camPar1);
			HalconAPI.UnpinTuple(camPar2);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covRelPose);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the essential matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="camMat1">Camera matrix of the 1st camera.</param>
		/// <param name="camMat2">Camera matrix of the 2nd camera.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the essential matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covEMat">9x9 covariance matrix of the essential matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed essential matrix.</returns>
		// Token: 0x060006A6 RID: 1702 RVA: 0x00028124 File Offset: 0x00026324
		public HHomMat2D MatchEssentialMatrixRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HHomMat2D camMat1, HHomMat2D camMat2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out HTuple covEMat, out HTuple error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(360);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, camMat1);
			HalconAPI.Store(proc, 5, camMat2);
			HalconAPI.StoreS(proc, 6, grayMatchMethod);
			HalconAPI.StoreI(proc, 7, maskSize);
			HalconAPI.StoreI(proc, 8, rowMove);
			HalconAPI.StoreI(proc, 9, colMove);
			HalconAPI.StoreI(proc, 10, rowTolerance);
			HalconAPI.StoreI(proc, 11, colTolerance);
			HalconAPI.Store(proc, 12, rotation);
			HalconAPI.Store(proc, 13, matchThreshold);
			HalconAPI.StoreS(proc, 14, estimationMethod);
			HalconAPI.Store(proc, 15, distanceThreshold);
			HalconAPI.StoreI(proc, 16, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(camMat1);
			HalconAPI.UnpinTuple(camMat2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covEMat);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the essential matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="camMat1">Camera matrix of the 1st camera.</param>
		/// <param name="camMat2">Camera matrix of the 2nd camera.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the essential matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covEMat">9x9 covariance matrix of the essential matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed essential matrix.</returns>
		// Token: 0x060006A7 RID: 1703 RVA: 0x000282BC File Offset: 0x000264BC
		public HHomMat2D MatchEssentialMatrixRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HHomMat2D camMat1, HHomMat2D camMat2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple covEMat, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(360);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, camMat1);
			HalconAPI.Store(proc, 5, camMat2);
			HalconAPI.StoreS(proc, 6, grayMatchMethod);
			HalconAPI.StoreI(proc, 7, maskSize);
			HalconAPI.StoreI(proc, 8, rowMove);
			HalconAPI.StoreI(proc, 9, colMove);
			HalconAPI.StoreI(proc, 10, rowTolerance);
			HalconAPI.StoreI(proc, 11, colTolerance);
			HalconAPI.StoreD(proc, 12, rotation);
			HalconAPI.StoreI(proc, 13, matchThreshold);
			HalconAPI.StoreS(proc, 14, estimationMethod);
			HalconAPI.StoreD(proc, 15, distanceThreshold);
			HalconAPI.StoreI(proc, 16, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(camMat1);
			HalconAPI.UnpinTuple(camMat2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covEMat);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed fundamental matrix.</returns>
		// Token: 0x060006A8 RID: 1704 RVA: 0x0002843C File Offset: 0x0002663C
		public HHomMat2D MatchFundamentalMatrixRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out HTuple covFMat, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(361);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covFMat);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed fundamental matrix.</returns>
		// Token: 0x060006A9 RID: 1705 RVA: 0x0002859C File Offset: 0x0002679C
		public HHomMat2D MatchFundamentalMatrixRansac(HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple covFMat, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(361);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covFMat);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the distance values for a rectified stereo image pair using correlation techniques.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Evaluation of a distance value.</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Point transformation from the rectified camera 2 to the rectified camera 1.</param>
		/// <param name="method">Matching function. Default: "ncc"</param>
		/// <param name="maskWidth">Width of the correlation window. Default: 11</param>
		/// <param name="maskHeight">Height of the correlation window. Default: 11</param>
		/// <param name="textureThresh">Variance threshold of textured image regions. Default: 0.0</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: 0</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="numLevels">Number of pyramid levels. Default: 1</param>
		/// <param name="scoreThresh">Threshold of the correlation function. Default: 0.0</param>
		/// <param name="filter">Downstream filters. Default: "none"</param>
		/// <param name="subDistance">Distance interpolation. Default: "none"</param>
		/// <returns>Distance image.</returns>
		// Token: 0x060006AA RID: 1706 RVA: 0x000286E8 File Offset: 0x000268E8
		public HImage BinocularDistance(HImage imageRect2, out HImage score, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect, string method, int maskWidth, int maskHeight, HTuple textureThresh, int minDisparity, int maxDisparity, int numLevels, HTuple scoreThresh, HTuple filter, HTuple subDistance)
		{
			IntPtr proc = HalconAPI.PreCall(362);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.Store(proc, 0, camParamRect1);
			HalconAPI.Store(proc, 1, camParamRect2);
			HalconAPI.Store(proc, 2, relPoseRect);
			HalconAPI.StoreS(proc, 3, method);
			HalconAPI.StoreI(proc, 4, maskWidth);
			HalconAPI.StoreI(proc, 5, maskHeight);
			HalconAPI.Store(proc, 6, textureThresh);
			HalconAPI.StoreI(proc, 7, minDisparity);
			HalconAPI.StoreI(proc, 8, maxDisparity);
			HalconAPI.StoreI(proc, 9, numLevels);
			HalconAPI.Store(proc, 10, scoreThresh);
			HalconAPI.Store(proc, 11, filter);
			HalconAPI.Store(proc, 12, subDistance);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HalconAPI.UnpinTuple(textureThresh);
			HalconAPI.UnpinTuple(scoreThresh);
			HalconAPI.UnpinTuple(filter);
			HalconAPI.UnpinTuple(subDistance);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the distance values for a rectified stereo image pair using correlation techniques.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Evaluation of a distance value.</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Point transformation from the rectified camera 2 to the rectified camera 1.</param>
		/// <param name="method">Matching function. Default: "ncc"</param>
		/// <param name="maskWidth">Width of the correlation window. Default: 11</param>
		/// <param name="maskHeight">Height of the correlation window. Default: 11</param>
		/// <param name="textureThresh">Variance threshold of textured image regions. Default: 0.0</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: 0</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="numLevels">Number of pyramid levels. Default: 1</param>
		/// <param name="scoreThresh">Threshold of the correlation function. Default: 0.0</param>
		/// <param name="filter">Downstream filters. Default: "none"</param>
		/// <param name="subDistance">Distance interpolation. Default: "none"</param>
		/// <returns>Distance image.</returns>
		// Token: 0x060006AB RID: 1707 RVA: 0x00028818 File Offset: 0x00026A18
		public HImage BinocularDistance(HImage imageRect2, out HImage score, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect, string method, int maskWidth, int maskHeight, double textureThresh, int minDisparity, int maxDisparity, int numLevels, double scoreThresh, string filter, string subDistance)
		{
			IntPtr proc = HalconAPI.PreCall(362);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.Store(proc, 0, camParamRect1);
			HalconAPI.Store(proc, 1, camParamRect2);
			HalconAPI.Store(proc, 2, relPoseRect);
			HalconAPI.StoreS(proc, 3, method);
			HalconAPI.StoreI(proc, 4, maskWidth);
			HalconAPI.StoreI(proc, 5, maskHeight);
			HalconAPI.StoreD(proc, 6, textureThresh);
			HalconAPI.StoreI(proc, 7, minDisparity);
			HalconAPI.StoreI(proc, 8, maxDisparity);
			HalconAPI.StoreI(proc, 9, numLevels);
			HalconAPI.StoreD(proc, 10, scoreThresh);
			HalconAPI.StoreS(proc, 11, filter);
			HalconAPI.StoreS(proc, 12, subDistance);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the disparities of a rectified image pair using correlation techniques.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Evaluation of the disparity values.</param>
		/// <param name="method">Matching function. Default: "ncc"</param>
		/// <param name="maskWidth">Width of the correlation window. Default: 11</param>
		/// <param name="maskHeight">Height of the correlation window. Default: 11</param>
		/// <param name="textureThresh">Variance threshold of textured image regions. Default: 0.0</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: -30</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="numLevels">Number of pyramid levels. Default: 1</param>
		/// <param name="scoreThresh">Threshold of the correlation function. Default: 0.5</param>
		/// <param name="filter">Downstream filters. Default: "none"</param>
		/// <param name="subDisparity">Subpixel interpolation of disparities. Default: "none"</param>
		/// <returns>Disparity map.</returns>
		// Token: 0x060006AC RID: 1708 RVA: 0x0002892C File Offset: 0x00026B2C
		public HImage BinocularDisparity(HImage imageRect2, out HImage score, string method, int maskWidth, int maskHeight, HTuple textureThresh, int minDisparity, int maxDisparity, int numLevels, HTuple scoreThresh, HTuple filter, string subDisparity)
		{
			IntPtr proc = HalconAPI.PreCall(363);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.StoreI(proc, 2, maskHeight);
			HalconAPI.Store(proc, 3, textureThresh);
			HalconAPI.StoreI(proc, 4, minDisparity);
			HalconAPI.StoreI(proc, 5, maxDisparity);
			HalconAPI.StoreI(proc, 6, numLevels);
			HalconAPI.Store(proc, 7, scoreThresh);
			HalconAPI.Store(proc, 8, filter);
			HalconAPI.StoreS(proc, 9, subDisparity);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(textureThresh);
			HalconAPI.UnpinTuple(scoreThresh);
			HalconAPI.UnpinTuple(filter);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Compute the disparities of a rectified image pair using correlation techniques.
		///   Instance represents: Rectified image of camera 1.
		/// </summary>
		/// <param name="imageRect2">Rectified image of camera 2.</param>
		/// <param name="score">Evaluation of the disparity values.</param>
		/// <param name="method">Matching function. Default: "ncc"</param>
		/// <param name="maskWidth">Width of the correlation window. Default: 11</param>
		/// <param name="maskHeight">Height of the correlation window. Default: 11</param>
		/// <param name="textureThresh">Variance threshold of textured image regions. Default: 0.0</param>
		/// <param name="minDisparity">Minimum of the expected disparities. Default: -30</param>
		/// <param name="maxDisparity">Maximum of the expected disparities. Default: 30</param>
		/// <param name="numLevels">Number of pyramid levels. Default: 1</param>
		/// <param name="scoreThresh">Threshold of the correlation function. Default: 0.5</param>
		/// <param name="filter">Downstream filters. Default: "none"</param>
		/// <param name="subDisparity">Subpixel interpolation of disparities. Default: "none"</param>
		/// <returns>Disparity map.</returns>
		// Token: 0x060006AD RID: 1709 RVA: 0x00028A04 File Offset: 0x00026C04
		public HImage BinocularDisparity(HImage imageRect2, out HImage score, string method, int maskWidth, int maskHeight, double textureThresh, int minDisparity, int maxDisparity, int numLevels, double scoreThresh, string filter, string subDisparity)
		{
			IntPtr proc = HalconAPI.PreCall(363);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.StoreI(proc, 2, maskHeight);
			HalconAPI.StoreD(proc, 3, textureThresh);
			HalconAPI.StoreI(proc, 4, minDisparity);
			HalconAPI.StoreI(proc, 5, maxDisparity);
			HalconAPI.StoreI(proc, 6, numLevels);
			HalconAPI.StoreD(proc, 7, scoreThresh);
			HalconAPI.StoreS(proc, 8, filter);
			HalconAPI.StoreS(proc, 9, subDisparity);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2);
			return result;
		}

		/// <summary>
		///   Transform a disparity image into 3D points in a rectified stereo system.
		///   Instance represents: Disparity image.
		/// </summary>
		/// <param name="y">Y coordinates of the points in the rectified camera system 1.</param>
		/// <param name="z">Z coordinates of the points in the rectified camera system 1.</param>
		/// <param name="camParamRect1">Internal camera parameters of the rectified camera 1.</param>
		/// <param name="camParamRect2">Internal camera parameters of the rectified camera 2.</param>
		/// <param name="relPoseRect">Pose of the rectified camera 2 in relation to the rectified camera 1.</param>
		/// <returns>X coordinates of the points in the rectified camera system 1.</returns>
		// Token: 0x060006AE RID: 1710 RVA: 0x00028AC8 File Offset: 0x00026CC8
		public HImage DisparityImageToXyz(out HImage y, out HImage z, HCamPar camParamRect1, HCamPar camParamRect2, HPose relPoseRect)
		{
			IntPtr proc = HalconAPI.PreCall(365);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, camParamRect1);
			HalconAPI.Store(proc, 1, camParamRect2);
			HalconAPI.Store(proc, 2, relPoseRect);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamRect1);
			HalconAPI.UnpinTuple(camParamRect2);
			HalconAPI.UnpinTuple(relPoseRect);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out y);
			num = HImage.LoadNew(proc, 3, num, out z);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Generate transformation maps that describe the mapping of the images of a binocular camera pair to a common rectified image plane.
		///   Modified instance represents: Image containing the mapping data of camera 1.
		/// </summary>
		/// <param name="camParam1">Internal parameters of camera 1.</param>
		/// <param name="camParam2">Internal parameters of camera 2.</param>
		/// <param name="relPose">Point transformation from camera 2 to camera 1.</param>
		/// <param name="subSampling">Subsampling factor. Default: 1.0</param>
		/// <param name="method">Type of rectification. Default: "viewing_direction"</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <param name="camParamRect1">Rectified internal parameters of camera 1.</param>
		/// <param name="camParamRect2">Rectified internal parameters of camera 2.</param>
		/// <param name="camPoseRect1">Point transformation from the rectified camera 1 to the original camera 1.</param>
		/// <param name="camPoseRect2">Point transformation from the rectified camera 1 to the original camera 1.</param>
		/// <param name="relPoseRect">Point transformation from the rectified camera 2 to the rectified camera 1.</param>
		/// <returns>Image containing the mapping data of camera 2.</returns>
		// Token: 0x060006AF RID: 1711 RVA: 0x00028B80 File Offset: 0x00026D80
		public HImage GenBinocularRectificationMap(HCamPar camParam1, HCamPar camParam2, HPose relPose, double subSampling, string method, string mapType, out HCamPar camParamRect1, out HCamPar camParamRect2, out HPose camPoseRect1, out HPose camPoseRect2, out HPose relPoseRect)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(369);
			HalconAPI.Store(proc, 0, camParam1);
			HalconAPI.Store(proc, 1, camParam2);
			HalconAPI.Store(proc, 2, relPose);
			HalconAPI.StoreD(proc, 3, subSampling);
			HalconAPI.StoreS(proc, 4, method);
			HalconAPI.StoreS(proc, 5, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam1);
			HalconAPI.UnpinTuple(camParam2);
			HalconAPI.UnpinTuple(relPose);
			num = base.Load(proc, 1, num);
			HImage result;
			num = HImage.LoadNew(proc, 2, num, out result);
			num = HCamPar.LoadNew(proc, 0, num, out camParamRect1);
			num = HCamPar.LoadNew(proc, 1, num, out camParamRect2);
			num = HPose.LoadNew(proc, 2, num, out camPoseRect1);
			num = HPose.LoadNew(proc, 3, num, out camPoseRect2);
			num = HPose.LoadNew(proc, 4, num, out relPoseRect);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the iconic results of a measurement performed with the sheet-of light technique.
		///   Modified instance represents: Desired measurement result.
		/// </summary>
		/// <param name="sheetOfLightModelID">Handle of the sheet-of-light model to be used.</param>
		/// <param name="resultName">Specify which result of the measurement shall be provided. Default: "disparity"</param>
		// Token: 0x060006B0 RID: 1712 RVA: 0x00028C9C File Offset: 0x00026E9C
		public void GetSheetOfLightResult(HSheetOfLightModel sheetOfLightModelID, HTuple resultName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(381);
			HalconAPI.Store(proc, 0, sheetOfLightModelID);
			HalconAPI.Store(proc, 1, resultName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(resultName);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sheetOfLightModelID);
		}

		/// <summary>
		///   Get the iconic results of a measurement performed with the sheet-of light technique.
		///   Modified instance represents: Desired measurement result.
		/// </summary>
		/// <param name="sheetOfLightModelID">Handle of the sheet-of-light model to be used.</param>
		/// <param name="resultName">Specify which result of the measurement shall be provided. Default: "disparity"</param>
		// Token: 0x060006B1 RID: 1713 RVA: 0x00028CFC File Offset: 0x00026EFC
		public void GetSheetOfLightResult(HSheetOfLightModel sheetOfLightModelID, string resultName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(381);
			HalconAPI.Store(proc, 0, sheetOfLightModelID);
			HalconAPI.StoreS(proc, 1, resultName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sheetOfLightModelID);
		}

		/// <summary>
		///   Apply the calibration transformations to the input disparity image.
		///   Instance represents: Height or range image to be calibrated.
		/// </summary>
		/// <param name="sheetOfLightModelID">Handle of the sheet-of-light model.</param>
		// Token: 0x060006B2 RID: 1714 RVA: 0x00028D58 File Offset: 0x00026F58
		public void ApplySheetOfLightCalibration(HSheetOfLightModel sheetOfLightModelID)
		{
			IntPtr proc = HalconAPI.PreCall(382);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sheetOfLightModelID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(sheetOfLightModelID);
		}

		/// <summary>
		///   Set sheet of light profiles by measured disparities.
		///   Instance represents: Disparity image that contains several profiles.
		/// </summary>
		/// <param name="sheetOfLightModelID">Handle of the sheet-of-light model.</param>
		/// <param name="movementPoses">Poses describing the movement of the scene under measurement between the previously processed profile image and the current profile image.</param>
		// Token: 0x060006B3 RID: 1715 RVA: 0x00028D9C File Offset: 0x00026F9C
		public void SetProfileSheetOfLight(HSheetOfLightModel sheetOfLightModelID, HTuple movementPoses)
		{
			IntPtr proc = HalconAPI.PreCall(383);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sheetOfLightModelID);
			HalconAPI.Store(proc, 1, movementPoses);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(movementPoses);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(sheetOfLightModelID);
		}

		/// <summary>
		///   Process the profile image provided as input and store the resulting disparity to the sheet-of-light model.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sheetOfLightModelID">Handle of the sheet-of-light model.</param>
		/// <param name="movementPose">Pose describing the movement of the scene under measurement between the previously processed profile image and the current profile image.</param>
		// Token: 0x060006B4 RID: 1716 RVA: 0x00028DEC File Offset: 0x00026FEC
		public void MeasureProfileSheetOfLight(HSheetOfLightModel sheetOfLightModelID, HTuple movementPose)
		{
			IntPtr proc = HalconAPI.PreCall(384);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sheetOfLightModelID);
			HalconAPI.Store(proc, 1, movementPose);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(movementPose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(sheetOfLightModelID);
		}

		/// <summary>
		///   Shade a height field.
		///   Instance represents: Height field to be shaded.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 0.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 0.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <param name="shadows">Should shadows be calculated? Default: "false"</param>
		/// <returns>Shaded image.</returns>
		// Token: 0x060006B5 RID: 1717 RVA: 0x00028E3C File Offset: 0x0002703C
		public HImage ShadeHeightField(HTuple slant, HTuple tilt, HTuple albedo, HTuple ambient, string shadows)
		{
			IntPtr proc = HalconAPI.PreCall(392);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, slant);
			HalconAPI.Store(proc, 1, tilt);
			HalconAPI.Store(proc, 2, albedo);
			HalconAPI.Store(proc, 3, ambient);
			HalconAPI.StoreS(proc, 4, shadows);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(slant);
			HalconAPI.UnpinTuple(tilt);
			HalconAPI.UnpinTuple(albedo);
			HalconAPI.UnpinTuple(ambient);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shade a height field.
		///   Instance represents: Height field to be shaded.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 0.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 0.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <param name="shadows">Should shadows be calculated? Default: "false"</param>
		/// <returns>Shaded image.</returns>
		// Token: 0x060006B6 RID: 1718 RVA: 0x00028EC8 File Offset: 0x000270C8
		public HImage ShadeHeightField(double slant, double tilt, double albedo, double ambient, string shadows)
		{
			IntPtr proc = HalconAPI.PreCall(392);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, slant);
			HalconAPI.StoreD(proc, 1, tilt);
			HalconAPI.StoreD(proc, 2, albedo);
			HalconAPI.StoreD(proc, 3, ambient);
			HalconAPI.StoreS(proc, 4, shadows);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the albedo of a surface and the amount of ambient light.
		///   Instance represents: Image for which albedo and ambient are to be estimated.
		/// </summary>
		/// <param name="ambient">Amount of ambient light.</param>
		/// <returns>Amount of light reflected by the surface.</returns>
		// Token: 0x060006B7 RID: 1719 RVA: 0x00028F3C File Offset: 0x0002713C
		public HTuple EstimateAlAm(out HTuple ambient)
		{
			IntPtr proc = HalconAPI.PreCall(393);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out ambient);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the albedo of a surface and the amount of ambient light.
		///   Instance represents: Image for which albedo and ambient are to be estimated.
		/// </summary>
		/// <param name="ambient">Amount of ambient light.</param>
		/// <returns>Amount of light reflected by the surface.</returns>
		// Token: 0x060006B8 RID: 1720 RVA: 0x00028F98 File Offset: 0x00027198
		public double EstimateAlAm(out double ambient)
		{
			IntPtr proc = HalconAPI.PreCall(393);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out ambient);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the slant of a light source and the albedo of a surface.
		///   Instance represents: Image for which slant and albedo are to be estimated.
		/// </summary>
		/// <param name="albedo">Amount of light reflected by the surface.</param>
		/// <returns>Angle of the light sources and the positive z-axis (in degrees).</returns>
		// Token: 0x060006B9 RID: 1721 RVA: 0x00028FF4 File Offset: 0x000271F4
		public HTuple EstimateSlAlZc(out HTuple albedo)
		{
			IntPtr proc = HalconAPI.PreCall(394);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out albedo);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the slant of a light source and the albedo of a surface.
		///   Instance represents: Image for which slant and albedo are to be estimated.
		/// </summary>
		/// <param name="albedo">Amount of light reflected by the surface.</param>
		/// <returns>Angle of the light sources and the positive z-axis (in degrees).</returns>
		// Token: 0x060006BA RID: 1722 RVA: 0x00029050 File Offset: 0x00027250
		public double EstimateSlAlZc(out double albedo)
		{
			IntPtr proc = HalconAPI.PreCall(394);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out albedo);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the slant of a light source and the albedo of a surface.
		///   Instance represents: Image for which slant and albedo are to be estimated.
		/// </summary>
		/// <param name="albedo">Amount of light reflected by the surface.</param>
		/// <returns>Angle between the light sources and the positive z-axis (in degrees).</returns>
		// Token: 0x060006BB RID: 1723 RVA: 0x000290AC File Offset: 0x000272AC
		public HTuple EstimateSlAlLr(out HTuple albedo)
		{
			IntPtr proc = HalconAPI.PreCall(395);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out albedo);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the slant of a light source and the albedo of a surface.
		///   Instance represents: Image for which slant and albedo are to be estimated.
		/// </summary>
		/// <param name="albedo">Amount of light reflected by the surface.</param>
		/// <returns>Angle between the light sources and the positive z-axis (in degrees).</returns>
		// Token: 0x060006BC RID: 1724 RVA: 0x00029108 File Offset: 0x00027308
		public double EstimateSlAlLr(out double albedo)
		{
			IntPtr proc = HalconAPI.PreCall(395);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out albedo);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the tilt of a light source.
		///   Instance represents: Image for which the tilt is to be estimated.
		/// </summary>
		/// <returns>Angle between the light source and the x-axis after projection into the xy-plane (in degrees).</returns>
		// Token: 0x060006BD RID: 1725 RVA: 0x00029164 File Offset: 0x00027364
		public HTuple EstimateTiltZc()
		{
			IntPtr proc = HalconAPI.PreCall(396);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the tilt of a light source.
		///   Instance represents: Image for which the tilt is to be estimated.
		/// </summary>
		/// <returns>Angle between the light source and the x-axis after projection into the xy-plane (in degrees).</returns>
		// Token: 0x060006BE RID: 1726 RVA: 0x000291B0 File Offset: 0x000273B0
		public HTuple EstimateTiltLr()
		{
			IntPtr proc = HalconAPI.PreCall(397);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface from surface gradients.
		///   Instance represents: The gradient field of the image.
		/// </summary>
		/// <param name="reconstructionMethod">Type of the reconstruction method. Default: "poisson"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006BF RID: 1727 RVA: 0x000291FC File Offset: 0x000273FC
		public HImage ReconstructHeightFieldFromGradient(string reconstructionMethod, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(398);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, reconstructionMethod);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface according to the photometric stereo technique.
		///   Instance represents: Array with at least three input images with different directions of illumination.
		/// </summary>
		/// <param name="gradient">The gradient field of the surface.</param>
		/// <param name="albedo">The albedo of the surface.</param>
		/// <param name="slants">Angle between the camera and the direction of  illumination (in degrees). Default: 45.0</param>
		/// <param name="tilts">Angle of the direction of illumination within the object plane (in degrees). Default: 45.0</param>
		/// <param name="resultType">Types of the requested results. Default: "all"</param>
		/// <param name="reconstructionMethod">Type of the reconstruction method. Default: "poisson"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006C0 RID: 1728 RVA: 0x00029268 File Offset: 0x00027468
		public HImage PhotometricStereo(out HImage gradient, out HImage albedo, HTuple slants, HTuple tilts, HTuple resultType, string reconstructionMethod, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(399);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, slants);
			HalconAPI.Store(proc, 1, tilts);
			HalconAPI.Store(proc, 2, resultType);
			HalconAPI.StoreS(proc, 3, reconstructionMethod);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(slants);
			HalconAPI.UnpinTuple(tilts);
			HalconAPI.UnpinTuple(resultType);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out gradient);
			num = HImage.LoadNew(proc, 3, num, out albedo);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface from a gray value image.
		///   Instance represents: Shaded input image.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 45.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 45.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006C1 RID: 1729 RVA: 0x0002932C File Offset: 0x0002752C
		public HImage SfsPentland(HTuple slant, HTuple tilt, HTuple albedo, HTuple ambient)
		{
			IntPtr proc = HalconAPI.PreCall(400);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, slant);
			HalconAPI.Store(proc, 1, tilt);
			HalconAPI.Store(proc, 2, albedo);
			HalconAPI.Store(proc, 3, ambient);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(slant);
			HalconAPI.UnpinTuple(tilt);
			HalconAPI.UnpinTuple(albedo);
			HalconAPI.UnpinTuple(ambient);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface from a gray value image.
		///   Instance represents: Shaded input image.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 45.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 45.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006C2 RID: 1730 RVA: 0x000293B0 File Offset: 0x000275B0
		public HImage SfsPentland(double slant, double tilt, double albedo, double ambient)
		{
			IntPtr proc = HalconAPI.PreCall(400);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, slant);
			HalconAPI.StoreD(proc, 1, tilt);
			HalconAPI.StoreD(proc, 2, albedo);
			HalconAPI.StoreD(proc, 3, ambient);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface from a gray value image.
		///   Instance represents: Shaded input image.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 45.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 45.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006C3 RID: 1731 RVA: 0x0002941C File Offset: 0x0002761C
		public HImage SfsOrigLr(HTuple slant, HTuple tilt, HTuple albedo, HTuple ambient)
		{
			IntPtr proc = HalconAPI.PreCall(401);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, slant);
			HalconAPI.Store(proc, 1, tilt);
			HalconAPI.Store(proc, 2, albedo);
			HalconAPI.Store(proc, 3, ambient);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(slant);
			HalconAPI.UnpinTuple(tilt);
			HalconAPI.UnpinTuple(albedo);
			HalconAPI.UnpinTuple(ambient);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface from a gray value image.
		///   Instance represents: Shaded input image.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 45.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 45.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006C4 RID: 1732 RVA: 0x000294A0 File Offset: 0x000276A0
		public HImage SfsOrigLr(double slant, double tilt, double albedo, double ambient)
		{
			IntPtr proc = HalconAPI.PreCall(401);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, slant);
			HalconAPI.StoreD(proc, 1, tilt);
			HalconAPI.StoreD(proc, 2, albedo);
			HalconAPI.StoreD(proc, 3, ambient);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface from a gray value image.
		///   Instance represents: Shaded input image.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 45.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 45.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006C5 RID: 1733 RVA: 0x0002950C File Offset: 0x0002770C
		public HImage SfsModLr(HTuple slant, HTuple tilt, HTuple albedo, HTuple ambient)
		{
			IntPtr proc = HalconAPI.PreCall(402);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, slant);
			HalconAPI.Store(proc, 1, tilt);
			HalconAPI.Store(proc, 2, albedo);
			HalconAPI.Store(proc, 3, ambient);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(slant);
			HalconAPI.UnpinTuple(tilt);
			HalconAPI.UnpinTuple(albedo);
			HalconAPI.UnpinTuple(ambient);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reconstruct a surface from a gray value image.
		///   Instance represents: Shaded input image.
		/// </summary>
		/// <param name="slant">Angle between the light source and the positive z-axis (in degrees). Default: 45.0</param>
		/// <param name="tilt">Angle between the light source and the x-axis after projection into the xy-plane (in degrees). Default: 45.0</param>
		/// <param name="albedo">Amount of light reflected by the surface. Default: 1.0</param>
		/// <param name="ambient">Amount of ambient light. Default: 0.0</param>
		/// <returns>Reconstructed height field.</returns>
		// Token: 0x060006C6 RID: 1734 RVA: 0x00029590 File Offset: 0x00027790
		public HImage SfsModLr(double slant, double tilt, double albedo, double ambient)
		{
			IntPtr proc = HalconAPI.PreCall(402);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, slant);
			HalconAPI.StoreD(proc, 1, tilt);
			HalconAPI.StoreD(proc, 2, albedo);
			HalconAPI.StoreD(proc, 3, ambient);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find text in an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="textModel">Text model specifying the text to be segmented.</param>
		/// <returns>Result of the segmentation.</returns>
		// Token: 0x060006C7 RID: 1735 RVA: 0x000295FC File Offset: 0x000277FC
		public HTextResult FindText(HTextModel textModel)
		{
			IntPtr proc = HalconAPI.PreCall(417);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, textModel);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTextResult result;
			num = HTextResult.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(textModel);
			return result;
		}

		/// <summary>
		///   Classify a byte image using a look-up table.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="classLUTHandle">Handle of the LUT classifier.</param>
		/// <returns>Segmented classes.</returns>
		// Token: 0x060006C8 RID: 1736 RVA: 0x00029654 File Offset: 0x00027854
		public HRegion ClassifyImageClassLut(HClassLUT classLUTHandle)
		{
			IntPtr proc = HalconAPI.PreCall(428);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, classLUTHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(classLUTHandle);
			return result;
		}

		/// <summary>
		///   Classify an image with a k-Nearest-Neighbor classifier.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="distanceImage">Distance of the pixel's nearest neighbor.</param>
		/// <param name="KNNHandle">Handle of the k-NN classifier.</param>
		/// <param name="rejectionThreshold">Threshold for the rejection of the classification. Default: 0.5</param>
		/// <returns>Segmented classes.</returns>
		// Token: 0x060006C9 RID: 1737 RVA: 0x000296AC File Offset: 0x000278AC
		public HRegion ClassifyImageClassKnn(out HImage distanceImage, HClassKnn KNNHandle, double rejectionThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(429);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, KNNHandle);
			HalconAPI.StoreD(proc, 1, rejectionThreshold);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out distanceImage);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(KNNHandle);
			return result;
		}

		/// <summary>
		///   Add training samples from an image to the training data of a k-Nearest-Neighbor classifier.
		///   Instance represents: Training image.
		/// </summary>
		/// <param name="classRegions">Regions of the classes to be trained.</param>
		/// <param name="KNNHandle">Handle of the k-NN classifier.</param>
		// Token: 0x060006CA RID: 1738 RVA: 0x0002971C File Offset: 0x0002791C
		public void AddSamplesImageClassKnn(HRegion classRegions, HClassKnn KNNHandle)
		{
			IntPtr proc = HalconAPI.PreCall(430);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, classRegions);
			HalconAPI.Store(proc, 0, KNNHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(classRegions);
			GC.KeepAlive(KNNHandle);
		}

		/// <summary>
		///   Classify an image with a Gaussian Mixture Model.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="GMMHandle">GMM handle.</param>
		/// <param name="rejectionThreshold">Threshold for the rejection of the classification. Default: 0.5</param>
		/// <returns>Segmented classes.</returns>
		// Token: 0x060006CB RID: 1739 RVA: 0x0002976C File Offset: 0x0002796C
		public HRegion ClassifyImageClassGmm(HClassGmm GMMHandle, double rejectionThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(431);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, GMMHandle);
			HalconAPI.StoreD(proc, 1, rejectionThreshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(GMMHandle);
			return result;
		}

		/// <summary>
		///   Add training samples from an image to the training data of a Gaussian Mixture Model.
		///   Instance represents: Training image.
		/// </summary>
		/// <param name="classRegions">Regions of the classes to be trained.</param>
		/// <param name="GMMHandle">GMM handle.</param>
		/// <param name="randomize">Standard deviation of the Gaussian noise added to the training data. Default: 0.0</param>
		// Token: 0x060006CC RID: 1740 RVA: 0x000297CC File Offset: 0x000279CC
		public void AddSamplesImageClassGmm(HRegion classRegions, HClassGmm GMMHandle, double randomize)
		{
			IntPtr proc = HalconAPI.PreCall(432);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, classRegions);
			HalconAPI.Store(proc, 0, GMMHandle);
			HalconAPI.StoreD(proc, 1, randomize);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(classRegions);
			GC.KeepAlive(GMMHandle);
		}

		/// <summary>
		///   Classify an image with a support vector machine.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="SVMHandle">SVM handle.</param>
		/// <returns>Segmented classes.</returns>
		// Token: 0x060006CD RID: 1741 RVA: 0x00029824 File Offset: 0x00027A24
		public HRegion ClassifyImageClassSvm(HClassSvm SVMHandle)
		{
			IntPtr proc = HalconAPI.PreCall(433);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, SVMHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(SVMHandle);
			return result;
		}

		/// <summary>
		///   Add training samples from an image to the training data of a support vector machine.
		///   Instance represents: Training image.
		/// </summary>
		/// <param name="classRegions">Regions of the classes to be trained.</param>
		/// <param name="SVMHandle">SVM handle.</param>
		// Token: 0x060006CE RID: 1742 RVA: 0x0002987C File Offset: 0x00027A7C
		public void AddSamplesImageClassSvm(HRegion classRegions, HClassSvm SVMHandle)
		{
			IntPtr proc = HalconAPI.PreCall(434);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, classRegions);
			HalconAPI.Store(proc, 0, SVMHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(classRegions);
			GC.KeepAlive(SVMHandle);
		}

		/// <summary>
		///   Classify an image with a multilayer perceptron.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="MLPHandle">MLP handle.</param>
		/// <param name="rejectionThreshold">Threshold for the rejection of the classification. Default: 0.5</param>
		/// <returns>Segmented classes.</returns>
		// Token: 0x060006CF RID: 1743 RVA: 0x000298CC File Offset: 0x00027ACC
		public HRegion ClassifyImageClassMlp(HClassMlp MLPHandle, double rejectionThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(435);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, MLPHandle);
			HalconAPI.StoreD(proc, 1, rejectionThreshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(MLPHandle);
			return result;
		}

		/// <summary>
		///   Add training samples from an image to the training data of a multilayer perceptron.
		///   Instance represents: Training image.
		/// </summary>
		/// <param name="classRegions">Regions of the classes to be trained.</param>
		/// <param name="MLPHandle">MLP handle.</param>
		// Token: 0x060006D0 RID: 1744 RVA: 0x0002992C File Offset: 0x00027B2C
		public void AddSamplesImageClassMlp(HRegion classRegions, HClassMlp MLPHandle)
		{
			IntPtr proc = HalconAPI.PreCall(436);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, classRegions);
			HalconAPI.Store(proc, 0, MLPHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(classRegions);
			GC.KeepAlive(MLPHandle);
		}

		/// <summary>
		///   Construct classes for class_ndim_norm.
		///   Instance represents: Multi-channel training image.
		/// </summary>
		/// <param name="foreground">Foreground pixels to be trained.</param>
		/// <param name="background">Background pixels to be trained (rejection class).</param>
		/// <param name="metric">Metric to be used. Default: "euclid"</param>
		/// <param name="distance">Maximum cluster radius. Default: 10.0</param>
		/// <param name="minNumberPercent">The ratio of the number of pixels in a cluster to the total number of pixels (in percent) must be larger than MinNumberPercent (otherwise the cluster is not output). Default: 0.01</param>
		/// <param name="center">Coordinates of all cluster centers.</param>
		/// <param name="quality">Overlap of the rejection class with the classified objects (1: no overlap).</param>
		/// <returns>Cluster radii or half edge lengths.</returns>
		// Token: 0x060006D1 RID: 1745 RVA: 0x0002997C File Offset: 0x00027B7C
		public HTuple LearnNdimNorm(HRegion foreground, HRegion background, string metric, HTuple distance, HTuple minNumberPercent, out HTuple center, out double quality)
		{
			IntPtr proc = HalconAPI.PreCall(437);
			base.Store(proc, 3);
			HalconAPI.Store(proc, 1, foreground);
			HalconAPI.Store(proc, 2, background);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.Store(proc, 1, distance);
			HalconAPI.Store(proc, 2, minNumberPercent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(distance);
			HalconAPI.UnpinTuple(minNumberPercent);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out center);
			num = HalconAPI.LoadD(proc, 2, num, out quality);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(foreground);
			GC.KeepAlive(background);
			return result;
		}

		/// <summary>
		///   Construct classes for class_ndim_norm.
		///   Instance represents: Multi-channel training image.
		/// </summary>
		/// <param name="foreground">Foreground pixels to be trained.</param>
		/// <param name="background">Background pixels to be trained (rejection class).</param>
		/// <param name="metric">Metric to be used. Default: "euclid"</param>
		/// <param name="distance">Maximum cluster radius. Default: 10.0</param>
		/// <param name="minNumberPercent">The ratio of the number of pixels in a cluster to the total number of pixels (in percent) must be larger than MinNumberPercent (otherwise the cluster is not output). Default: 0.01</param>
		/// <param name="center">Coordinates of all cluster centers.</param>
		/// <param name="quality">Overlap of the rejection class with the classified objects (1: no overlap).</param>
		/// <returns>Cluster radii or half edge lengths.</returns>
		// Token: 0x060006D2 RID: 1746 RVA: 0x00029A30 File Offset: 0x00027C30
		public HTuple LearnNdimNorm(HRegion foreground, HRegion background, string metric, double distance, double minNumberPercent, out HTuple center, out double quality)
		{
			IntPtr proc = HalconAPI.PreCall(437);
			base.Store(proc, 3);
			HalconAPI.Store(proc, 1, foreground);
			HalconAPI.Store(proc, 2, background);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.StoreD(proc, 1, distance);
			HalconAPI.StoreD(proc, 2, minNumberPercent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out center);
			num = HalconAPI.LoadD(proc, 2, num, out quality);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(foreground);
			GC.KeepAlive(background);
			return result;
		}

		/// <summary>
		///   Train a classificator using a multi-channel image.
		///   Instance represents: Multi-channel training image.
		/// </summary>
		/// <param name="foreground">Foreground pixels to be trained.</param>
		/// <param name="background">Background pixels to be trained (rejection class).</param>
		/// <param name="classifHandle">Handle of the classifier.</param>
		// Token: 0x060006D3 RID: 1747 RVA: 0x00029AD8 File Offset: 0x00027CD8
		public void LearnNdimBox(HRegion foreground, HRegion background, HClassBox classifHandle)
		{
			IntPtr proc = HalconAPI.PreCall(438);
			base.Store(proc, 3);
			HalconAPI.Store(proc, 1, foreground);
			HalconAPI.Store(proc, 2, background);
			HalconAPI.Store(proc, 0, classifHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(foreground);
			GC.KeepAlive(background);
			GC.KeepAlive(classifHandle);
		}

		/// <summary>
		///   Classify pixels using hyper-cuboids.
		///   Instance represents: Multi channel input image.
		/// </summary>
		/// <param name="classifHandle">Handle of the classifier.</param>
		/// <returns>Classification result.</returns>
		// Token: 0x060006D4 RID: 1748 RVA: 0x00029B38 File Offset: 0x00027D38
		public HRegion ClassNdimBox(HClassBox classifHandle)
		{
			IntPtr proc = HalconAPI.PreCall(439);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, classifHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(classifHandle);
			return result;
		}

		/// <summary>
		///   Classify pixels using hyper-spheres or hyper-cubes.
		///   Instance represents: Multi channel input image.
		/// </summary>
		/// <param name="metric">Metric to be used. Default: "euclid"</param>
		/// <param name="singleMultiple">Return one region or one region for each cluster. Default: "single"</param>
		/// <param name="radius">Cluster radii or half edge lengths (returned by learn_ndim_norm).</param>
		/// <param name="center">Coordinates of the cluster centers (returned by learn_ndim_norm).</param>
		/// <returns>Classification result.</returns>
		// Token: 0x060006D5 RID: 1749 RVA: 0x00029B90 File Offset: 0x00027D90
		public HRegion ClassNdimNorm(string metric, string singleMultiple, HTuple radius, HTuple center)
		{
			IntPtr proc = HalconAPI.PreCall(440);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.StoreS(proc, 1, singleMultiple);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.Store(proc, 3, center);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(center);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Classify pixels using hyper-spheres or hyper-cubes.
		///   Instance represents: Multi channel input image.
		/// </summary>
		/// <param name="metric">Metric to be used. Default: "euclid"</param>
		/// <param name="singleMultiple">Return one region or one region for each cluster. Default: "single"</param>
		/// <param name="radius">Cluster radii or half edge lengths (returned by learn_ndim_norm).</param>
		/// <param name="center">Coordinates of the cluster centers (returned by learn_ndim_norm).</param>
		/// <returns>Classification result.</returns>
		// Token: 0x060006D6 RID: 1750 RVA: 0x00029C08 File Offset: 0x00027E08
		public HRegion ClassNdimNorm(string metric, string singleMultiple, double radius, double center)
		{
			IntPtr proc = HalconAPI.PreCall(440);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.StoreS(proc, 1, singleMultiple);
			HalconAPI.StoreD(proc, 2, radius);
			HalconAPI.StoreD(proc, 3, center);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using two-dimensional pixel classification.
		///   Instance represents: Input image (first channel).
		/// </summary>
		/// <param name="imageRow">Input image (second channel).</param>
		/// <param name="featureSpace">Region defining the feature space.</param>
		/// <returns>Classified regions.</returns>
		// Token: 0x060006D7 RID: 1751 RVA: 0x00029C74 File Offset: 0x00027E74
		public HRegion Class2dimSup(HImage imageRow, HRegion featureSpace)
		{
			IntPtr proc = HalconAPI.PreCall(441);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRow);
			HalconAPI.Store(proc, 3, featureSpace);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRow);
			GC.KeepAlive(featureSpace);
			return result;
		}

		/// <summary>
		///   Segment two images by clustering.
		///   Instance represents: First input image.
		/// </summary>
		/// <param name="image2">Second input image.</param>
		/// <param name="threshold">Threshold (maximum distance to the cluster's center). Default: 15</param>
		/// <param name="numClasses">Number of classes (cluster centers). Default: 5</param>
		/// <returns>Classification result.</returns>
		// Token: 0x060006D8 RID: 1752 RVA: 0x00029CD8 File Offset: 0x00027ED8
		public HRegion Class2dimUnsup(HImage image2, int threshold, int numClasses)
		{
			IntPtr proc = HalconAPI.PreCall(442);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.StoreI(proc, 0, threshold);
			HalconAPI.StoreI(proc, 1, numClasses);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compare two images pixel by pixel.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="pattern">Comparison image.</param>
		/// <param name="mode">Mode: return similar or different pixels. Default: "diff_outside"</param>
		/// <param name="diffLowerBound">Lower bound of the tolerated gray value difference. Default: -5</param>
		/// <param name="diffUpperBound">Upper bound of the tolerated gray value difference. Default: 5</param>
		/// <param name="grayOffset">Offset gray value subtracted from the input image. Default: 0</param>
		/// <param name="addRow">Row coordinate by which the comparison image is translated. Default: 0</param>
		/// <param name="addCol">Column coordinate by which the comparison image is translated. Default: 0</param>
		/// <returns>Points in which the two images are similar/different.</returns>
		// Token: 0x060006D9 RID: 1753 RVA: 0x00029D40 File Offset: 0x00027F40
		public HRegion CheckDifference(HImage pattern, string mode, int diffLowerBound, int diffUpperBound, int grayOffset, int addRow, int addCol)
		{
			IntPtr proc = HalconAPI.PreCall(443);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, pattern);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, diffLowerBound);
			HalconAPI.StoreI(proc, 2, diffUpperBound);
			HalconAPI.StoreI(proc, 3, grayOffset);
			HalconAPI.StoreI(proc, 4, addRow);
			HalconAPI.StoreI(proc, 5, addCol);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(pattern);
			return result;
		}

		/// <summary>
		///   Perform a threshold segmentation for extracting characters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="histoRegion">Region in which the histogram is computed.</param>
		/// <param name="sigma">Sigma for the Gaussian smoothing of the histogram. Default: 2.0</param>
		/// <param name="percent">Percentage for the gray value difference. Default: 95</param>
		/// <param name="threshold">Calculated threshold.</param>
		/// <returns>Dark regions (characters).</returns>
		// Token: 0x060006DA RID: 1754 RVA: 0x00029DCC File Offset: 0x00027FCC
		public HRegion CharThreshold(HRegion histoRegion, double sigma, HTuple percent, out HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(444);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, histoRegion);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.Store(proc, 1, percent);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(percent);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out threshold);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(histoRegion);
			return result;
		}

		/// <summary>
		///   Perform a threshold segmentation for extracting characters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="histoRegion">Region in which the histogram is computed.</param>
		/// <param name="sigma">Sigma for the Gaussian smoothing of the histogram. Default: 2.0</param>
		/// <param name="percent">Percentage for the gray value difference. Default: 95</param>
		/// <param name="threshold">Calculated threshold.</param>
		/// <returns>Dark regions (characters).</returns>
		// Token: 0x060006DB RID: 1755 RVA: 0x00029E4C File Offset: 0x0002804C
		public HRegion CharThreshold(HRegion histoRegion, double sigma, double percent, out int threshold)
		{
			IntPtr proc = HalconAPI.PreCall(444);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, histoRegion);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, percent);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HalconAPI.LoadI(proc, 0, num, out threshold);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(histoRegion);
			return result;
		}

		/// <summary>
		///   Extract regions with equal gray values from an image.
		///   Instance represents: Label image.
		/// </summary>
		/// <returns>Regions having a constant gray value.</returns>
		// Token: 0x060006DC RID: 1756 RVA: 0x00029EC8 File Offset: 0x000280C8
		public HRegion LabelToRegion()
		{
			IntPtr proc = HalconAPI.PreCall(445);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Suppress non-maximum points on an edge.
		///   Instance represents: Amplitude (gradient magnitude) image.
		/// </summary>
		/// <param name="mode">Select horizontal/vertical or undirected NMS. Default: "hvnms"</param>
		/// <returns>Image with thinned edge regions.</returns>
		// Token: 0x060006DD RID: 1757 RVA: 0x00029F10 File Offset: 0x00028110
		public HImage NonmaxSuppressionAmp(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(446);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Suppress non-maximum points on an edge using a direction image.
		///   Instance represents: Amplitude (gradient magnitude) image.
		/// </summary>
		/// <param name="imgDir">Direction image.</param>
		/// <param name="mode">Select non-maximum-suppression or interpolating NMS. Default: "nms"</param>
		/// <returns>Image with thinned edge regions.</returns>
		// Token: 0x060006DE RID: 1758 RVA: 0x00029F60 File Offset: 0x00028160
		public HImage NonmaxSuppressionDir(HImage imgDir, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(447);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imgDir);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imgDir);
			return result;
		}

		/// <summary>
		///   Perform a hysteresis threshold operation on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="low">Lower threshold for the gray values. Default: 30</param>
		/// <param name="high">Upper threshold for the gray values. Default: 60</param>
		/// <param name="maxLength">Maximum length of a path of "potential" points to reach a "secure" point. Default: 10</param>
		/// <returns>Segmented region.</returns>
		// Token: 0x060006DF RID: 1759 RVA: 0x00029FC0 File Offset: 0x000281C0
		public HRegion HysteresisThreshold(HTuple low, HTuple high, int maxLength)
		{
			IntPtr proc = HalconAPI.PreCall(448);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, low);
			HalconAPI.Store(proc, 1, high);
			HalconAPI.StoreI(proc, 2, maxLength);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(low);
			HalconAPI.UnpinTuple(high);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a hysteresis threshold operation on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="low">Lower threshold for the gray values. Default: 30</param>
		/// <param name="high">Upper threshold for the gray values. Default: 60</param>
		/// <param name="maxLength">Maximum length of a path of "potential" points to reach a "secure" point. Default: 10</param>
		/// <returns>Segmented region.</returns>
		// Token: 0x060006E0 RID: 1760 RVA: 0x0002A02C File Offset: 0x0002822C
		public HRegion HysteresisThreshold(int low, int high, int maxLength)
		{
			IntPtr proc = HalconAPI.PreCall(448);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, low);
			HalconAPI.StoreI(proc, 1, high);
			HalconAPI.StoreI(proc, 2, maxLength);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using binary thresholding.
		///   Instance represents: Input Image.
		/// </summary>
		/// <param name="method">Segmentation method. Default: "max_separability"</param>
		/// <param name="lightDark">Extract foreground or background? Default: "dark"</param>
		/// <param name="usedThreshold">Used threshold.</param>
		/// <returns>Segmented output region.</returns>
		// Token: 0x060006E1 RID: 1761 RVA: 0x0002A08C File Offset: 0x0002828C
		public HRegion BinaryThreshold(string method, string lightDark, out HTuple usedThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(449);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreS(proc, 1, lightDark);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, num, out usedThreshold);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using binary thresholding.
		///   Instance represents: Input Image.
		/// </summary>
		/// <param name="method">Segmentation method. Default: "max_separability"</param>
		/// <param name="lightDark">Extract foreground or background? Default: "dark"</param>
		/// <param name="usedThreshold">Used threshold.</param>
		/// <returns>Segmented output region.</returns>
		// Token: 0x060006E2 RID: 1762 RVA: 0x0002A0F8 File Offset: 0x000282F8
		public HRegion BinaryThreshold(string method, string lightDark, out int usedThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(449);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreS(proc, 1, lightDark);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HalconAPI.LoadI(proc, 0, num, out usedThreshold);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using local thresholding.
		///   Instance represents: Input Image.
		/// </summary>
		/// <param name="method">Segmentation method. Default: "adapted_std_deviation"</param>
		/// <param name="lightDark">Extract foreground or background? Default: "dark"</param>
		/// <param name="genParamName">List of generic parameter names. Default: []</param>
		/// <param name="genParamValue">List of generic parameter values. Default: []</param>
		/// <returns>Segmented output region.</returns>
		// Token: 0x060006E3 RID: 1763 RVA: 0x0002A164 File Offset: 0x00028364
		public HRegion LocalThreshold(string method, string lightDark, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(450);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreS(proc, 1, lightDark);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using local thresholding.
		///   Instance represents: Input Image.
		/// </summary>
		/// <param name="method">Segmentation method. Default: "adapted_std_deviation"</param>
		/// <param name="lightDark">Extract foreground or background? Default: "dark"</param>
		/// <param name="genParamName">List of generic parameter names. Default: []</param>
		/// <param name="genParamValue">List of generic parameter values. Default: []</param>
		/// <returns>Segmented output region.</returns>
		// Token: 0x060006E4 RID: 1764 RVA: 0x0002A1DC File Offset: 0x000283DC
		public HRegion LocalThreshold(string method, string lightDark, string genParamName, int genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(450);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreS(proc, 1, lightDark);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreI(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Threshold an image by local mean and standard deviation analysis.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskWidth">Mask width for mean and deviation calculation. Default: 15</param>
		/// <param name="maskHeight">Mask height for mean and deviation calculation. Default: 15</param>
		/// <param name="stdDevScale">Factor for the standard deviation of the gray values. Default: 0.2</param>
		/// <param name="absThreshold">Minimum gray value difference from the mean. Default: 2</param>
		/// <param name="lightDark">Threshold type. Default: "dark"</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006E5 RID: 1765 RVA: 0x0002A248 File Offset: 0x00028448
		public HRegion VarThreshold(int maskWidth, int maskHeight, HTuple stdDevScale, HTuple absThreshold, string lightDark)
		{
			IntPtr proc = HalconAPI.PreCall(451);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.Store(proc, 2, stdDevScale);
			HalconAPI.Store(proc, 3, absThreshold);
			HalconAPI.StoreS(proc, 4, lightDark);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(stdDevScale);
			HalconAPI.UnpinTuple(absThreshold);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Threshold an image by local mean and standard deviation analysis.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskWidth">Mask width for mean and deviation calculation. Default: 15</param>
		/// <param name="maskHeight">Mask height for mean and deviation calculation. Default: 15</param>
		/// <param name="stdDevScale">Factor for the standard deviation of the gray values. Default: 0.2</param>
		/// <param name="absThreshold">Minimum gray value difference from the mean. Default: 2</param>
		/// <param name="lightDark">Threshold type. Default: "dark"</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006E6 RID: 1766 RVA: 0x0002A2C8 File Offset: 0x000284C8
		public HRegion VarThreshold(int maskWidth, int maskHeight, double stdDevScale, double absThreshold, string lightDark)
		{
			IntPtr proc = HalconAPI.PreCall(451);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreD(proc, 2, stdDevScale);
			HalconAPI.StoreD(proc, 3, absThreshold);
			HalconAPI.StoreS(proc, 4, lightDark);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using a local threshold.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="thresholdImage">Image containing the local thresholds.</param>
		/// <param name="offset">Offset applied to ThresholdImage. Default: 5.0</param>
		/// <param name="lightDark">Extract light, dark or similar areas? Default: "light"</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006E7 RID: 1767 RVA: 0x0002A33C File Offset: 0x0002853C
		public HRegion DynThreshold(HImage thresholdImage, HTuple offset, string lightDark)
		{
			IntPtr proc = HalconAPI.PreCall(452);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, thresholdImage);
			HalconAPI.Store(proc, 0, offset);
			HalconAPI.StoreS(proc, 1, lightDark);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(offset);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(thresholdImage);
			return result;
		}

		/// <summary>
		///   Segment an image using a local threshold.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="thresholdImage">Image containing the local thresholds.</param>
		/// <param name="offset">Offset applied to ThresholdImage. Default: 5.0</param>
		/// <param name="lightDark">Extract light, dark or similar areas? Default: "light"</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006E8 RID: 1768 RVA: 0x0002A3A8 File Offset: 0x000285A8
		public HRegion DynThreshold(HImage thresholdImage, double offset, string lightDark)
		{
			IntPtr proc = HalconAPI.PreCall(452);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, thresholdImage);
			HalconAPI.StoreD(proc, 0, offset);
			HalconAPI.StoreS(proc, 1, lightDark);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(thresholdImage);
			return result;
		}

		/// <summary>
		///   Segment an image using global threshold.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="minGray">Lower threshold for the gray values or 'min'. Default: 128.0</param>
		/// <param name="maxGray">Upper threshold for the gray values or 'max'. Default: 255.0</param>
		/// <returns>Segmented region.</returns>
		// Token: 0x060006E9 RID: 1769 RVA: 0x0002A410 File Offset: 0x00028610
		public HRegion Threshold(HTuple minGray, HTuple maxGray)
		{
			IntPtr proc = HalconAPI.PreCall(453);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, minGray);
			HalconAPI.Store(proc, 1, maxGray);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minGray);
			HalconAPI.UnpinTuple(maxGray);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using global threshold.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="minGray">Lower threshold for the gray values or 'min'. Default: 128.0</param>
		/// <param name="maxGray">Upper threshold for the gray values or 'max'. Default: 255.0</param>
		/// <returns>Segmented region.</returns>
		// Token: 0x060006EA RID: 1770 RVA: 0x0002A474 File Offset: 0x00028674
		public HRegion Threshold(double minGray, double maxGray)
		{
			IntPtr proc = HalconAPI.PreCall(453);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, minGray);
			HalconAPI.StoreD(proc, 1, maxGray);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract level crossings from an image with subpixel accuracy.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="threshold">Threshold for the level crossings. Default: 128</param>
		/// <returns>Extracted level crossings.</returns>
		// Token: 0x060006EB RID: 1771 RVA: 0x0002A4CC File Offset: 0x000286CC
		public HXLDCont ThresholdSubPix(HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(454);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(threshold);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract level crossings from an image with subpixel accuracy.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="threshold">Threshold for the level crossings. Default: 128</param>
		/// <returns>Extracted level crossings.</returns>
		// Token: 0x060006EC RID: 1772 RVA: 0x0002A524 File Offset: 0x00028724
		public HXLDCont ThresholdSubPix(double threshold)
		{
			IntPtr proc = HalconAPI.PreCall(454);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using regiongrowing for multi-channel images.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="metric">Metric for the distance of the feature vectors. Default: "2-norm"</param>
		/// <param name="minTolerance">Lower threshold for the features' distance. Default: 0.0</param>
		/// <param name="maxTolerance">Upper threshold for the features' distance. Default: 20.0</param>
		/// <param name="minSize">Minimum size of the output regions. Default: 30</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006ED RID: 1773 RVA: 0x0002A574 File Offset: 0x00028774
		public HRegion RegiongrowingN(string metric, HTuple minTolerance, HTuple maxTolerance, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(455);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.Store(proc, 1, minTolerance);
			HalconAPI.Store(proc, 2, maxTolerance);
			HalconAPI.StoreI(proc, 3, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minTolerance);
			HalconAPI.UnpinTuple(maxTolerance);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using regiongrowing for multi-channel images.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="metric">Metric for the distance of the feature vectors. Default: "2-norm"</param>
		/// <param name="minTolerance">Lower threshold for the features' distance. Default: 0.0</param>
		/// <param name="maxTolerance">Upper threshold for the features' distance. Default: 20.0</param>
		/// <param name="minSize">Minimum size of the output regions. Default: 30</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006EE RID: 1774 RVA: 0x0002A5EC File Offset: 0x000287EC
		public HRegion RegiongrowingN(string metric, double minTolerance, double maxTolerance, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(455);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, metric);
			HalconAPI.StoreD(proc, 1, minTolerance);
			HalconAPI.StoreD(proc, 2, maxTolerance);
			HalconAPI.StoreI(proc, 3, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using regiongrowing.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="rasterHeight">Vertical distance between tested pixels (height of the raster). Default: 3</param>
		/// <param name="rasterWidth">Horizontal distance between tested pixels (height of the raster). Default: 3</param>
		/// <param name="tolerance">Points with a gray value difference less then or equal to tolerance are accumulated into the same object. Default: 6.0</param>
		/// <param name="minSize">Minimum size of the output regions. Default: 100</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006EF RID: 1775 RVA: 0x0002A658 File Offset: 0x00028858
		public HRegion Regiongrowing(int rasterHeight, int rasterWidth, HTuple tolerance, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(456);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, rasterHeight);
			HalconAPI.StoreI(proc, 1, rasterWidth);
			HalconAPI.Store(proc, 2, tolerance);
			HalconAPI.StoreI(proc, 3, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(tolerance);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using regiongrowing.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="rasterHeight">Vertical distance between tested pixels (height of the raster). Default: 3</param>
		/// <param name="rasterWidth">Horizontal distance between tested pixels (height of the raster). Default: 3</param>
		/// <param name="tolerance">Points with a gray value difference less then or equal to tolerance are accumulated into the same object. Default: 6.0</param>
		/// <param name="minSize">Minimum size of the output regions. Default: 100</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006F0 RID: 1776 RVA: 0x0002A6C8 File Offset: 0x000288C8
		public HRegion Regiongrowing(int rasterHeight, int rasterWidth, double tolerance, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(456);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, rasterHeight);
			HalconAPI.StoreI(proc, 1, rasterWidth);
			HalconAPI.StoreD(proc, 2, tolerance);
			HalconAPI.StoreI(proc, 3, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a regiongrowing using mean gray values.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="startRows">Row coordinates of the starting points. Default: []</param>
		/// <param name="startColumns">Column coordinates of the starting points. Default: []</param>
		/// <param name="tolerance">Maximum deviation from the mean. Default: 5.0</param>
		/// <param name="minSize">Minimum size of a region. Default: 100</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006F1 RID: 1777 RVA: 0x0002A734 File Offset: 0x00028934
		public HRegion RegiongrowingMean(HTuple startRows, HTuple startColumns, double tolerance, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(457);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, startRows);
			HalconAPI.Store(proc, 1, startColumns);
			HalconAPI.StoreD(proc, 2, tolerance);
			HalconAPI.StoreI(proc, 3, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(startRows);
			HalconAPI.UnpinTuple(startColumns);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a regiongrowing using mean gray values.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="startRows">Row coordinates of the starting points. Default: []</param>
		/// <param name="startColumns">Column coordinates of the starting points. Default: []</param>
		/// <param name="tolerance">Maximum deviation from the mean. Default: 5.0</param>
		/// <param name="minSize">Minimum size of a region. Default: 100</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006F2 RID: 1778 RVA: 0x0002A7AC File Offset: 0x000289AC
		public HRegion RegiongrowingMean(int startRows, int startColumns, double tolerance, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(457);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, startRows);
			HalconAPI.StoreI(proc, 1, startColumns);
			HalconAPI.StoreD(proc, 2, tolerance);
			HalconAPI.StoreI(proc, 3, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image by "pouring water" over it.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="mode">Mode of operation. Default: "all"</param>
		/// <param name="minGray">All gray values smaller than this threshold are disregarded. Default: 0</param>
		/// <param name="maxGray">All gray values larger than this threshold are disregarded. Default: 255</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x060006F3 RID: 1779 RVA: 0x0002A818 File Offset: 0x00028A18
		public HRegion Pouring(string mode, int minGray, int maxGray)
		{
			IntPtr proc = HalconAPI.PreCall(458);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, minGray);
			HalconAPI.StoreI(proc, 2, maxGray);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract watershed basins from an image using a threshold.
		///   Instance represents: Image to be segmented.
		/// </summary>
		/// <param name="threshold">Threshold for the watersheds. Default: 10</param>
		/// <returns>Segments found (dark basins).</returns>
		// Token: 0x060006F4 RID: 1780 RVA: 0x0002A878 File Offset: 0x00028A78
		public HRegion WatershedsThreshold(HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(459);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(threshold);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract watershed basins from an image using a threshold.
		///   Instance represents: Image to be segmented.
		/// </summary>
		/// <param name="threshold">Threshold for the watersheds. Default: 10</param>
		/// <returns>Segments found (dark basins).</returns>
		// Token: 0x060006F5 RID: 1781 RVA: 0x0002A8D0 File Offset: 0x00028AD0
		public HRegion WatershedsThreshold(int threshold)
		{
			IntPtr proc = HalconAPI.PreCall(459);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract watersheds and basins from an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="watersheds">Watersheds between the basins.</param>
		/// <returns>Segmented basins.</returns>
		// Token: 0x060006F6 RID: 1782 RVA: 0x0002A920 File Offset: 0x00028B20
		public HRegion Watersheds(out HRegion watersheds)
		{
			IntPtr proc = HalconAPI.PreCall(460);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out watersheds);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract zero crossings from an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Zero crossings.</returns>
		// Token: 0x060006F7 RID: 1783 RVA: 0x0002A97C File Offset: 0x00028B7C
		public HRegion ZeroCrossing()
		{
			IntPtr proc = HalconAPI.PreCall(461);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract zero crossings from an image with subpixel accuracy.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Extracted zero crossings.</returns>
		// Token: 0x060006F8 RID: 1784 RVA: 0x0002A9C4 File Offset: 0x00028BC4
		public HXLDCont ZeroCrossingSubPix()
		{
			IntPtr proc = HalconAPI.PreCall(462);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Threshold operator for signed images.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="minSize">Regions smaller than MinSize are suppressed. Default: 20</param>
		/// <param name="minGray">Regions whose maximum absolute gray value is smaller than MinGray are suppressed. Default: 5.0</param>
		/// <param name="threshold">Regions that have a gray value smaller than Threshold (or larger than -Threshold) are suppressed. Default: 2.0</param>
		/// <returns>Positive and negative regions.</returns>
		// Token: 0x060006F9 RID: 1785 RVA: 0x0002AA0C File Offset: 0x00028C0C
		public HRegion DualThreshold(int minSize, double minGray, double threshold)
		{
			IntPtr proc = HalconAPI.PreCall(463);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, minSize);
			HalconAPI.StoreD(proc, 1, minGray);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Expand a region starting at a given line.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="coordinate">Row or column coordinate. Default: 256</param>
		/// <param name="expandType">Stopping criterion. Default: "gradient"</param>
		/// <param name="rowColumn">Segmentation mode (row or column). Default: "row"</param>
		/// <param name="threshold">Threshold for the expansion. Default: 3.0</param>
		/// <returns>Extracted segments.</returns>
		// Token: 0x060006FA RID: 1786 RVA: 0x0002AA6C File Offset: 0x00028C6C
		public HRegion ExpandLine(int coordinate, string expandType, string rowColumn, HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(464);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, coordinate);
			HalconAPI.StoreS(proc, 1, expandType);
			HalconAPI.StoreS(proc, 2, rowColumn);
			HalconAPI.Store(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(threshold);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Expand a region starting at a given line.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="coordinate">Row or column coordinate. Default: 256</param>
		/// <param name="expandType">Stopping criterion. Default: "gradient"</param>
		/// <param name="rowColumn">Segmentation mode (row or column). Default: "row"</param>
		/// <param name="threshold">Threshold for the expansion. Default: 3.0</param>
		/// <returns>Extracted segments.</returns>
		// Token: 0x060006FB RID: 1787 RVA: 0x0002AADC File Offset: 0x00028CDC
		public HRegion ExpandLine(int coordinate, string expandType, string rowColumn, double threshold)
		{
			IntPtr proc = HalconAPI.PreCall(464);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, coordinate);
			HalconAPI.StoreS(proc, 1, expandType);
			HalconAPI.StoreS(proc, 2, rowColumn);
			HalconAPI.StoreD(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect all local minima in an image.
		///   Instance represents: Image to be processed.
		/// </summary>
		/// <returns>Extracted local minima as regions.</returns>
		// Token: 0x060006FC RID: 1788 RVA: 0x0002AB48 File Offset: 0x00028D48
		public HRegion LocalMin()
		{
			IntPtr proc = HalconAPI.PreCall(465);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect all gray value lowlands.
		///   Instance represents: Image to be processed.
		/// </summary>
		/// <returns>Extracted lowlands as regions (one region for each lowland).</returns>
		// Token: 0x060006FD RID: 1789 RVA: 0x0002AB90 File Offset: 0x00028D90
		public HRegion Lowlands()
		{
			IntPtr proc = HalconAPI.PreCall(466);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect the centers of all gray value lowlands.
		///   Instance represents: Image to be processed.
		/// </summary>
		/// <returns>Centers of gravity of the extracted lowlands as regions (one region for each lowland).</returns>
		// Token: 0x060006FE RID: 1790 RVA: 0x0002ABD8 File Offset: 0x00028DD8
		public HRegion LowlandsCenter()
		{
			IntPtr proc = HalconAPI.PreCall(467);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect all local maxima in an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Extracted local maxima as a region.</returns>
		// Token: 0x060006FF RID: 1791 RVA: 0x0002AC20 File Offset: 0x00028E20
		public HRegion LocalMax()
		{
			IntPtr proc = HalconAPI.PreCall(468);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect all gray value plateaus.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Extracted plateaus as regions (one region for each plateau).</returns>
		// Token: 0x06000700 RID: 1792 RVA: 0x0002AC68 File Offset: 0x00028E68
		public HRegion Plateaus()
		{
			IntPtr proc = HalconAPI.PreCall(469);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect the centers of all gray value plateaus.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Centers of gravity of the extracted plateaus as regions (one region for each plateau).</returns>
		// Token: 0x06000701 RID: 1793 RVA: 0x0002ACB0 File Offset: 0x00028EB0
		public HRegion PlateausCenter()
		{
			IntPtr proc = HalconAPI.PreCall(470);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using thresholds determined from its histogram.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Sigma for the Gaussian smoothing of the histogram. Default: 2.0</param>
		/// <returns>Regions with gray values within the automatically determined intervals.</returns>
		// Token: 0x06000702 RID: 1794 RVA: 0x0002ACF8 File Offset: 0x00028EF8
		public HRegion AutoThreshold(HTuple sigma)
		{
			IntPtr proc = HalconAPI.PreCall(472);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sigma);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigma);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using thresholds determined from its histogram.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Sigma for the Gaussian smoothing of the histogram. Default: 2.0</param>
		/// <returns>Regions with gray values within the automatically determined intervals.</returns>
		// Token: 0x06000703 RID: 1795 RVA: 0x0002AD50 File Offset: 0x00028F50
		public HRegion AutoThreshold(double sigma)
		{
			IntPtr proc = HalconAPI.PreCall(472);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment an image using an automatically determined threshold.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Dark regions of the image.</returns>
		// Token: 0x06000704 RID: 1796 RVA: 0x0002ADA0 File Offset: 0x00028FA0
		public HRegion BinThreshold()
		{
			IntPtr proc = HalconAPI.PreCall(473);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fast thresholding of images using global thresholds.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="minGray">Lower threshold for the gray values. Default: 128</param>
		/// <param name="maxGray">Upper threshold for the gray values. Default: 255.0</param>
		/// <param name="minSize">Minimum size of objects to be extracted. Default: 20</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x06000705 RID: 1797 RVA: 0x0002ADE8 File Offset: 0x00028FE8
		public HRegion FastThreshold(HTuple minGray, HTuple maxGray, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(474);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, minGray);
			HalconAPI.Store(proc, 1, maxGray);
			HalconAPI.StoreI(proc, 2, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minGray);
			HalconAPI.UnpinTuple(maxGray);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fast thresholding of images using global thresholds.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="minGray">Lower threshold for the gray values. Default: 128</param>
		/// <param name="maxGray">Upper threshold for the gray values. Default: 255.0</param>
		/// <param name="minSize">Minimum size of objects to be extracted. Default: 20</param>
		/// <returns>Segmented regions.</returns>
		// Token: 0x06000706 RID: 1798 RVA: 0x0002AE54 File Offset: 0x00029054
		public HRegion FastThreshold(double minGray, double maxGray, int minSize)
		{
			IntPtr proc = HalconAPI.PreCall(474);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, minGray);
			HalconAPI.StoreD(proc, 1, maxGray);
			HalconAPI.StoreI(proc, 2, minSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Image (possibly multi-channel) for gray value or color comparison.
		/// </summary>
		/// <param name="regions">Regions for which the gaps are to be closed, or which are to be separated.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="threshold">Maximum difference between the gray value or color at the region's border and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x06000707 RID: 1799 RVA: 0x0002AEB4 File Offset: 0x000290B4
		public HRegion ExpandGray(HRegion regions, HRegion forbiddenArea, HTuple iterations, string mode, HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(509);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.Store(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.Store(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations);
			HalconAPI.UnpinTuple(threshold);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Image (possibly multi-channel) for gray value or color comparison.
		/// </summary>
		/// <param name="regions">Regions for which the gaps are to be closed, or which are to be separated.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="threshold">Maximum difference between the gray value or color at the region's border and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x06000708 RID: 1800 RVA: 0x0002AF40 File Offset: 0x00029140
		public HRegion ExpandGray(HRegion regions, HRegion forbiddenArea, string iterations, string mode, int threshold)
		{
			IntPtr proc = HalconAPI.PreCall(509);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.StoreS(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.StoreI(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Image (possibly multi-channel) for gray value or color comparison.
		/// </summary>
		/// <param name="regions">Regions for which the gaps are to be closed, or which are to be separated.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="refGray">Reference gray value or color for comparison. Default: 128</param>
		/// <param name="threshold">Maximum difference between the reference gray value or color and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x06000709 RID: 1801 RVA: 0x0002AFC0 File Offset: 0x000291C0
		public HRegion ExpandGrayRef(HRegion regions, HRegion forbiddenArea, HTuple iterations, string mode, HTuple refGray, HTuple threshold)
		{
			IntPtr proc = HalconAPI.PreCall(510);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.Store(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.Store(proc, 2, refGray);
			HalconAPI.Store(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations);
			HalconAPI.UnpinTuple(refGray);
			HalconAPI.UnpinTuple(threshold);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Fill gaps between regions (depending on gray value or color) or split overlapping regions.
		///   Instance represents: Image (possibly multi-channel) for gray value or color comparison.
		/// </summary>
		/// <param name="regions">Regions for which the gaps are to be closed, or which are to be separated.</param>
		/// <param name="forbiddenArea">Regions in which no expansion takes place.</param>
		/// <param name="iterations">Number of iterations. Default: "maximal"</param>
		/// <param name="mode">Expansion mode. Default: "image"</param>
		/// <param name="refGray">Reference gray value or color for comparison. Default: 128</param>
		/// <param name="threshold">Maximum difference between the reference gray value or color and a candidate for expansion. Default: 32</param>
		/// <returns>Expanded or separated regions.</returns>
		// Token: 0x0600070A RID: 1802 RVA: 0x0002B05C File Offset: 0x0002925C
		public HRegion ExpandGrayRef(HRegion regions, HRegion forbiddenArea, string iterations, string mode, int refGray, int threshold)
		{
			IntPtr proc = HalconAPI.PreCall(510);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 3, forbiddenArea);
			HalconAPI.StoreS(proc, 0, iterations);
			HalconAPI.StoreS(proc, 1, mode);
			HalconAPI.StoreI(proc, 2, refGray);
			HalconAPI.StoreI(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			GC.KeepAlive(forbiddenArea);
			return result;
		}

		/// <summary>
		///   Calculate the difference of two object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objectsSub">Object tuple 2.</param>
		/// <returns>Objects from Objects that are not part of ObjectsSub.</returns>
		// Token: 0x0600070B RID: 1803 RVA: 0x0002B0E4 File Offset: 0x000292E4
		public HImage ObjDiff(HImage objectsSub)
		{
			IntPtr proc = HalconAPI.PreCall(573);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsSub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsSub);
			return result;
		}

		/// <summary>
		///   Set single gray values in an image.
		///   Instance represents: Image to be modified.
		/// </summary>
		/// <param name="row">Row coordinates of the pixels to be modified. Default: 0</param>
		/// <param name="column">Column coordinates of the pixels to be modified. Default: 0</param>
		/// <param name="grayval">Gray values to be used. Default: 255.0</param>
		// Token: 0x0600070C RID: 1804 RVA: 0x0002B13C File Offset: 0x0002933C
		public void SetGrayval(HTuple row, HTuple column, HTuple grayval)
		{
			IntPtr proc = HalconAPI.PreCall(574);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, grayval);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(grayval);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set single gray values in an image.
		///   Instance represents: Image to be modified.
		/// </summary>
		/// <param name="row">Row coordinates of the pixels to be modified. Default: 0</param>
		/// <param name="column">Column coordinates of the pixels to be modified. Default: 0</param>
		/// <param name="grayval">Gray values to be used. Default: 255.0</param>
		// Token: 0x0600070D RID: 1805 RVA: 0x0002B19C File Offset: 0x0002939C
		public void SetGrayval(int row, int column, double grayval)
		{
			IntPtr proc = HalconAPI.PreCall(574);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreD(proc, 2, grayval);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Paint XLD objects into an image.
		///   Instance represents: Image in which the xld objects are to be painted.
		/// </summary>
		/// <param name="XLD">XLD objects to be painted into the input image.</param>
		/// <param name="grayval">Desired gray value of the xld object. Default: 255.0</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x0600070E RID: 1806 RVA: 0x0002B1E8 File Offset: 0x000293E8
		public HImage PaintXld(HXLD XLD, HTuple grayval)
		{
			IntPtr proc = HalconAPI.PreCall(575);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, XLD);
			HalconAPI.Store(proc, 0, grayval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayval);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(XLD);
			return result;
		}

		/// <summary>
		///   Paint XLD objects into an image.
		///   Instance represents: Image in which the xld objects are to be painted.
		/// </summary>
		/// <param name="XLD">XLD objects to be painted into the input image.</param>
		/// <param name="grayval">Desired gray value of the xld object. Default: 255.0</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x0600070F RID: 1807 RVA: 0x0002B24C File Offset: 0x0002944C
		public HImage PaintXld(HXLD XLD, double grayval)
		{
			IntPtr proc = HalconAPI.PreCall(575);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, XLD);
			HalconAPI.StoreD(proc, 0, grayval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(XLD);
			return result;
		}

		/// <summary>
		///   Paint regions into an image.
		///   Instance represents: Image in which the regions are to be painted.
		/// </summary>
		/// <param name="region">Regions to be painted into the input image.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x06000710 RID: 1808 RVA: 0x0002B2AC File Offset: 0x000294AC
		public HImage PaintRegion(HRegion region, HTuple grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(576);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, region);
			HalconAPI.Store(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayval);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Paint regions into an image.
		///   Instance represents: Image in which the regions are to be painted.
		/// </summary>
		/// <param name="region">Regions to be painted into the input image.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x06000711 RID: 1809 RVA: 0x0002B318 File Offset: 0x00029518
		public HImage PaintRegion(HRegion region, double grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(576);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, region);
			HalconAPI.StoreD(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Overpaint regions in an image.
		///   Instance represents: Image in which the regions are to be painted.
		/// </summary>
		/// <param name="region">Regions to be painted into the input image.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		// Token: 0x06000712 RID: 1810 RVA: 0x0002B380 File Offset: 0x00029580
		public void OverpaintRegion(HRegion region, HTuple grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(577);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.Store(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayval);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
		}

		/// <summary>
		///   Overpaint regions in an image.
		///   Instance represents: Image in which the regions are to be painted.
		/// </summary>
		/// <param name="region">Regions to be painted into the input image.</param>
		/// <param name="grayval">Desired gray values of the regions. Default: 255.0</param>
		/// <param name="type">Paint regions filled or as boundaries. Default: "fill"</param>
		// Token: 0x06000713 RID: 1811 RVA: 0x0002B3D8 File Offset: 0x000295D8
		public void OverpaintRegion(HRegion region, double grayval, string type)
		{
			IntPtr proc = HalconAPI.PreCall(577);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreD(proc, 0, grayval);
			HalconAPI.StoreS(proc, 1, type);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
		}

		/// <summary>
		///   Create an image with a specified constant gray value.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="grayval">Gray value to be used for the output image. Default: 0</param>
		/// <returns>Image with constant gray value.</returns>
		// Token: 0x06000714 RID: 1812 RVA: 0x0002B42C File Offset: 0x0002962C
		public HImage GenImageProto(HTuple grayval)
		{
			IntPtr proc = HalconAPI.PreCall(578);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, grayval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayval);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create an image with a specified constant gray value.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="grayval">Gray value to be used for the output image. Default: 0</param>
		/// <returns>Image with constant gray value.</returns>
		// Token: 0x06000715 RID: 1813 RVA: 0x0002B484 File Offset: 0x00029684
		public HImage GenImageProto(double grayval)
		{
			IntPtr proc = HalconAPI.PreCall(578);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, grayval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Paint the gray values of an image into another image.
		///   Instance represents: Input image containing the desired gray values.
		/// </summary>
		/// <param name="imageDestination">Input image to be painted over.</param>
		/// <returns>Result image.</returns>
		// Token: 0x06000716 RID: 1814 RVA: 0x0002B4D4 File Offset: 0x000296D4
		public HImage PaintGray(HImage imageDestination)
		{
			IntPtr proc = HalconAPI.PreCall(579);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageDestination);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageDestination);
			return result;
		}

		/// <summary>
		///   Overpaint the gray values of an image.
		///   Instance represents: Input image to be painted over.
		/// </summary>
		/// <param name="imageSource">Input image containing the desired gray values.</param>
		// Token: 0x06000717 RID: 1815 RVA: 0x0002B52C File Offset: 0x0002972C
		public void OverpaintGray(HImage imageSource)
		{
			IntPtr proc = HalconAPI.PreCall(580);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageSource);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(imageSource);
		}

		/// <summary>
		///   Copy an iconic object in the HALCON database.
		///   Instance represents: Objects to be copied.
		/// </summary>
		/// <param name="index">Starting index of the objects to be copied. Default: 1</param>
		/// <param name="numObj">Number of objects to be copied or -1. Default: 1</param>
		/// <returns>Copied objects.</returns>
		// Token: 0x06000718 RID: 1816 RVA: 0x0002B570 File Offset: 0x00029770
		public new HImage CopyObj(int index, int numObj)
		{
			IntPtr proc = HalconAPI.PreCall(583);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.StoreI(proc, 1, numObj);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Concatenate two iconic object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objects2">Object tuple 2.</param>
		/// <returns>Concatenated objects.</returns>
		// Token: 0x06000719 RID: 1817 RVA: 0x0002B5C8 File Offset: 0x000297C8
		public HImage ConcatObj(HImage objects2)
		{
			IntPtr proc = HalconAPI.PreCall(584);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Copy an image and allocate new memory for it.
		///   Instance represents: Image to be copied.
		/// </summary>
		/// <returns>Copied image.</returns>
		// Token: 0x0600071A RID: 1818 RVA: 0x0002B620 File Offset: 0x00029820
		public HImage CopyImage()
		{
			IntPtr proc = HalconAPI.PreCall(586);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x0600071B RID: 1819 RVA: 0x0002B668 File Offset: 0x00029868
		public new HImage SelectObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x0600071C RID: 1820 RVA: 0x0002B6C0 File Offset: 0x000298C0
		public new HImage SelectObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x0600071D RID: 1821 RVA: 0x0002B710 File Offset: 0x00029910
		public int CompareObj(HImage objects2, HTuple epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.Store(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(epsilon);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x0600071E RID: 1822 RVA: 0x0002B774 File Offset: 0x00029974
		public int CompareObj(HImage objects2, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare image objects regarding equality.
		///   Instance represents: Test objects.
		/// </summary>
		/// <param name="objects2">Comparative objects.</param>
		/// <returns>boolean result value.</returns>
		// Token: 0x0600071F RID: 1823 RVA: 0x0002B7D4 File Offset: 0x000299D4
		public int TestEqualObj(HImage objects2)
		{
			IntPtr proc = HalconAPI.PreCall(591);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Create a three-channel image from a pointer to the interleaved pixels.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="pixelPointer">Pointer to interleaved pixels.</param>
		/// <param name="colorFormat">Format of the input pixels. Default: "rgb"</param>
		/// <param name="originalWidth">Width of input image. Default: 512</param>
		/// <param name="originalHeight">Height of input image. Default: 512</param>
		/// <param name="alignment">Reserved.</param>
		/// <param name="type">Pixel type of output image. Default: "byte"</param>
		/// <param name="imageWidth">Width of output image. Default: 0</param>
		/// <param name="imageHeight">Height of output image. Default: 0</param>
		/// <param name="startRow">Line number of upper left corner of desired image part. Default: 0</param>
		/// <param name="startColumn">Column number of upper left corner of desired image part. Default: 0</param>
		/// <param name="bitsPerChannel">Number of used bits per pixel and channel of the output image (-1: All bits are used). Default: -1</param>
		/// <param name="bitShift">Number of bits that the color values of the input pixels are shifted to the right (only uint2 images). Default: 0</param>
		// Token: 0x06000720 RID: 1824 RVA: 0x0002B82C File Offset: 0x00029A2C
		public void GenImageInterleaved(IntPtr pixelPointer, string colorFormat, int originalWidth, int originalHeight, int alignment, string type, int imageWidth, int imageHeight, int startRow, int startColumn, int bitsPerChannel, int bitShift)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(595);
			HalconAPI.StoreIP(proc, 0, pixelPointer);
			HalconAPI.StoreS(proc, 1, colorFormat);
			HalconAPI.StoreI(proc, 2, originalWidth);
			HalconAPI.StoreI(proc, 3, originalHeight);
			HalconAPI.StoreI(proc, 4, alignment);
			HalconAPI.StoreS(proc, 5, type);
			HalconAPI.StoreI(proc, 6, imageWidth);
			HalconAPI.StoreI(proc, 7, imageHeight);
			HalconAPI.StoreI(proc, 8, startRow);
			HalconAPI.StoreI(proc, 9, startColumn);
			HalconAPI.StoreI(proc, 10, bitsPerChannel);
			HalconAPI.StoreI(proc, 11, bitShift);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an image from three pointers to the pixels (red/green/blue).
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		/// <param name="pixelPointerRed">Pointer to first red value (channel 1).</param>
		/// <param name="pixelPointerGreen">Pointer to first green value (channel 2).</param>
		/// <param name="pixelPointerBlue">Pointer to first blue value (channel 3).</param>
		// Token: 0x06000721 RID: 1825 RVA: 0x0002B8DC File Offset: 0x00029ADC
		public void GenImage3(string type, int width, int height, IntPtr pixelPointerRed, IntPtr pixelPointerGreen, IntPtr pixelPointerBlue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(605);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.StoreIP(proc, 3, pixelPointerRed);
			HalconAPI.StoreIP(proc, 4, pixelPointerGreen);
			HalconAPI.StoreIP(proc, 5, pixelPointerBlue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an image from a pointer to the pixels.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		/// <param name="pixelPointer">Pointer to first gray value.</param>
		// Token: 0x06000722 RID: 1826 RVA: 0x0002B954 File Offset: 0x00029B54
		public void GenImage1(string type, int width, int height, IntPtr pixelPointer)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(606);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.StoreIP(proc, 3, pixelPointer);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an image with constant gray value.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		// Token: 0x06000723 RID: 1827 RVA: 0x0002B9BC File Offset: 0x00029BBC
		public void GenImageConst(string type, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(607);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a gray value ramp.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="alpha">Gradient in line direction. Default: 1.0</param>
		/// <param name="beta">Gradient in column direction. Default: 1.0</param>
		/// <param name="mean">Mean gray value. Default: 128</param>
		/// <param name="row">Line index of reference point. Default: 256</param>
		/// <param name="column">Column index of reference point. Default: 256</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		// Token: 0x06000724 RID: 1828 RVA: 0x0002BA18 File Offset: 0x00029C18
		public void GenImageGrayRamp(double alpha, double beta, double mean, int row, int column, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(619);
			HalconAPI.StoreD(proc, 0, alpha);
			HalconAPI.StoreD(proc, 1, beta);
			HalconAPI.StoreD(proc, 2, mean);
			HalconAPI.StoreI(proc, 3, row);
			HalconAPI.StoreI(proc, 4, column);
			HalconAPI.StoreI(proc, 5, width);
			HalconAPI.StoreI(proc, 6, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a three-channel image from three pointers on the pixels with storage management.
		///   Modified instance represents: Created HALCON image.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		/// <param name="pointerRed">Pointer to the first gray value of the first channel.</param>
		/// <param name="pointerGreen">Pointer to the first gray value of the second channel.</param>
		/// <param name="pointerBlue">Pointer to the first gray value of the third channel.</param>
		/// <param name="clearProc">Pointer to the procedure re-releasing the memory of the image when deleting the object. Default: 0</param>
		// Token: 0x06000725 RID: 1829 RVA: 0x0002BA98 File Offset: 0x00029C98
		public void GenImage3Extern(string type, int width, int height, IntPtr pointerRed, IntPtr pointerGreen, IntPtr pointerBlue, IntPtr clearProc)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(620);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.StoreIP(proc, 3, pointerRed);
			HalconAPI.StoreIP(proc, 4, pointerGreen);
			HalconAPI.StoreIP(proc, 5, pointerBlue);
			HalconAPI.StoreIP(proc, 6, clearProc);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an image from a pointer on the pixels with storage management.
		///   Modified instance represents: Created HALCON image.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		/// <param name="pixelPointer">Pointer to the first gray value.</param>
		/// <param name="clearProc">Pointer to the procedure re-releasing the memory of the image when deleting the object. Default: 0</param>
		// Token: 0x06000726 RID: 1830 RVA: 0x0002BB18 File Offset: 0x00029D18
		public void GenImage1Extern(string type, int width, int height, IntPtr pixelPointer, IntPtr clearProc)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(621);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.StoreIP(proc, 3, pixelPointer);
			HalconAPI.StoreIP(proc, 4, clearProc);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an image with a rectangular domain from a pointer on the pixels (with storage management).
		///   Modified instance represents: Created HALCON image.
		/// </summary>
		/// <param name="pixelPointer">Pointer to the first pixel.</param>
		/// <param name="width">Width of the image. Default: 512</param>
		/// <param name="height">Height of the image. Default: 512</param>
		/// <param name="verticalPitch">Distance (in bytes) between pixel m in row n and pixel m in row n+1 of the 'input image'.</param>
		/// <param name="horizontalBitPitch">Distance between two neighboring pixels in bits . Default: 8</param>
		/// <param name="bitsPerPixel">Number of used bits per pixel. Default: 8</param>
		/// <param name="doCopy">Copy image data. Default: "false"</param>
		/// <param name="clearProc">Pointer to the procedure releasing the memory of the image when deleting the object. Default: 0</param>
		// Token: 0x06000727 RID: 1831 RVA: 0x0002BB88 File Offset: 0x00029D88
		public void GenImage1Rect(IntPtr pixelPointer, int width, int height, int verticalPitch, int horizontalBitPitch, int bitsPerPixel, string doCopy, IntPtr clearProc)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(622);
			HalconAPI.StoreIP(proc, 0, pixelPointer);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.StoreI(proc, 3, verticalPitch);
			HalconAPI.StoreI(proc, 4, horizontalBitPitch);
			HalconAPI.StoreI(proc, 5, bitsPerPixel);
			HalconAPI.StoreS(proc, 6, doCopy);
			HalconAPI.StoreIP(proc, 7, clearProc);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access to the image data pointer and the image data inside the smallest rectangle of the domain of the input image.
		///   Instance represents: Input image (Himage).
		/// </summary>
		/// <param name="width">Width of the output image.</param>
		/// <param name="height">Height of the output image.</param>
		/// <param name="verticalPitch">Width(input image)*(HorizontalBitPitch/8).</param>
		/// <param name="horizontalBitPitch">Distance between two neighboring pixels in bits .</param>
		/// <param name="bitsPerPixel">Number of used bits per pixel.</param>
		/// <returns>Pointer to the image data.</returns>
		// Token: 0x06000728 RID: 1832 RVA: 0x0002BC14 File Offset: 0x00029E14
		public IntPtr GetImagePointer1Rect(out int width, out int height, out int verticalPitch, out int horizontalBitPitch, out int bitsPerPixel)
		{
			IntPtr proc = HalconAPI.PreCall(623);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			IntPtr result;
			num = HalconAPI.LoadIP(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out width);
			num = HalconAPI.LoadI(proc, 2, num, out height);
			num = HalconAPI.LoadI(proc, 3, num, out verticalPitch);
			num = HalconAPI.LoadI(proc, 4, num, out horizontalBitPitch);
			num = HalconAPI.LoadI(proc, 5, num, out bitsPerPixel);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Access the pointers of a colored image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="pointerRed">Pointer to the pixels of the first channel.</param>
		/// <param name="pointerGreen">Pointer to the pixels of the second channel.</param>
		/// <param name="pointerBlue">Pointer to the pixels of the third channel.</param>
		/// <param name="type">Type of image.</param>
		/// <param name="width">Width of image.</param>
		/// <param name="height">Height of image.</param>
		// Token: 0x06000729 RID: 1833 RVA: 0x0002BCB8 File Offset: 0x00029EB8
		public void GetImagePointer3(out HTuple pointerRed, out HTuple pointerGreen, out HTuple pointerBlue, out HTuple type, out HTuple width, out HTuple height)
		{
			IntPtr proc = HalconAPI.PreCall(624);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out pointerRed);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out pointerGreen);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out pointerBlue);
			num = HTuple.LoadNew(proc, 3, num, out type);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out width);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access the pointers of a colored image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="pointerRed">Pointer to the pixels of the first channel.</param>
		/// <param name="pointerGreen">Pointer to the pixels of the second channel.</param>
		/// <param name="pointerBlue">Pointer to the pixels of the third channel.</param>
		/// <param name="type">Type of image.</param>
		/// <param name="width">Width of image.</param>
		/// <param name="height">Height of image.</param>
		// Token: 0x0600072A RID: 1834 RVA: 0x0002BD60 File Offset: 0x00029F60
		public void GetImagePointer3(out IntPtr pointerRed, out IntPtr pointerGreen, out IntPtr pointerBlue, out string type, out int width, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(624);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadIP(proc, 0, num, out pointerRed);
			num = HalconAPI.LoadIP(proc, 1, num, out pointerGreen);
			num = HalconAPI.LoadIP(proc, 2, num, out pointerBlue);
			num = HalconAPI.LoadS(proc, 3, num, out type);
			num = HalconAPI.LoadI(proc, 4, num, out width);
			num = HalconAPI.LoadI(proc, 5, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Access the pointer of a channel.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="type">Type of image.</param>
		/// <param name="width">Width of image.</param>
		/// <param name="height">Height of image.</param>
		/// <returns>Pointer to the image data in the HALCON database.</returns>
		// Token: 0x0600072B RID: 1835 RVA: 0x0002BE04 File Offset: 0x0002A004
		public HTuple GetImagePointer1(out HTuple type, out HTuple width, out HTuple height)
		{
			IntPtr proc = HalconAPI.PreCall(625);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out type);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out width);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Access the pointer of a channel.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="type">Type of image.</param>
		/// <param name="width">Width of image.</param>
		/// <param name="height">Height of image.</param>
		/// <returns>Pointer to the image data in the HALCON database.</returns>
		// Token: 0x0600072C RID: 1836 RVA: 0x0002BE88 File Offset: 0x0002A088
		public IntPtr GetImagePointer1(out string type, out int width, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(625);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			IntPtr result;
			num = HalconAPI.LoadIP(proc, 0, num, out result);
			num = HalconAPI.LoadS(proc, 1, num, out type);
			num = HalconAPI.LoadI(proc, 2, num, out width);
			num = HalconAPI.LoadI(proc, 3, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the type of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Type of image.</returns>
		// Token: 0x0600072D RID: 1837 RVA: 0x0002BF08 File Offset: 0x0002A108
		public HTuple GetImageType()
		{
			IntPtr proc = HalconAPI.PreCall(626);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the size of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="width">Width of image.</param>
		/// <param name="height">Height of image.</param>
		// Token: 0x0600072E RID: 1838 RVA: 0x0002BF50 File Offset: 0x0002A150
		public void GetImageSize(out HTuple width, out HTuple height)
		{
			IntPtr proc = HalconAPI.PreCall(627);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out width);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the size of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="width">Width of image.</param>
		/// <param name="height">Height of image.</param>
		// Token: 0x0600072F RID: 1839 RVA: 0x0002BFAC File Offset: 0x0002A1AC
		public void GetImageSize(out int width, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(627);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out width);
			num = HalconAPI.LoadI(proc, 1, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Request time at which the image was created.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="second">Seconds (0..59).</param>
		/// <param name="minute">Minutes (0..59).</param>
		/// <param name="hour">Hours (0..23).</param>
		/// <param name="day">Day of the month (1..31).</param>
		/// <param name="YDay">Day of the year (1..366).</param>
		/// <param name="month">Month (1..12).</param>
		/// <param name="year">Year (xxxx).</param>
		/// <returns>Milliseconds (0..999).</returns>
		// Token: 0x06000730 RID: 1840 RVA: 0x0002C004 File Offset: 0x0002A204
		public int GetImageTime(out int second, out int minute, out int hour, out int day, out int YDay, out int month, out int year)
		{
			IntPtr proc = HalconAPI.PreCall(628);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out second);
			num = HalconAPI.LoadI(proc, 2, num, out minute);
			num = HalconAPI.LoadI(proc, 3, num, out hour);
			num = HalconAPI.LoadI(proc, 4, num, out day);
			num = HalconAPI.LoadI(proc, 5, num, out YDay);
			num = HalconAPI.LoadI(proc, 6, num, out month);
			num = HalconAPI.LoadI(proc, 7, num, out year);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return gray values of an image at the positions given by tuples of rows and columns.
		///   Instance represents: Image whose gray values are to be accessed.
		/// </summary>
		/// <param name="row">Row coordinates of positions. Default: 0</param>
		/// <param name="column">Column coordinates of positions. Default: 0</param>
		/// <param name="interpolation">Interpolation method. Default: "bilinear"</param>
		/// <returns>Gray values of the selected image coordinates.</returns>
		// Token: 0x06000731 RID: 1841 RVA: 0x0002C0D0 File Offset: 0x0002A2D0
		public HTuple GetGrayvalInterpolated(HTuple row, HTuple column, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(629);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return gray values of an image at the positions given by tuples of rows and columns.
		///   Instance represents: Image whose gray values are to be accessed.
		/// </summary>
		/// <param name="row">Row coordinates of positions. Default: 0</param>
		/// <param name="column">Column coordinates of positions. Default: 0</param>
		/// <param name="interpolation">Interpolation method. Default: "bilinear"</param>
		/// <returns>Gray values of the selected image coordinates.</returns>
		// Token: 0x06000732 RID: 1842 RVA: 0x0002C140 File Offset: 0x0002A340
		public double GetGrayvalInterpolated(double row, double column, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(629);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Access the gray values of an image object.
		///   Instance represents: Image whose gray value is to be accessed.
		/// </summary>
		/// <param name="row">Row coordinates of pixels to be viewed. Default: 0</param>
		/// <param name="column">Column coordinates of pixels to be viewed. Default: 0</param>
		/// <returns>Gray values of indicated pixels.</returns>
		// Token: 0x06000733 RID: 1843 RVA: 0x0002C1A0 File Offset: 0x0002A3A0
		public HTuple GetGrayval(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(630);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Access the gray values of an image object.
		///   Instance represents: Image whose gray value is to be accessed.
		/// </summary>
		/// <param name="row">Row coordinates of pixels to be viewed. Default: 0</param>
		/// <param name="column">Column coordinates of pixels to be viewed. Default: 0</param>
		/// <returns>Gray values of indicated pixels.</returns>
		// Token: 0x06000734 RID: 1844 RVA: 0x0002C204 File Offset: 0x0002A404
		public HTuple GetGrayval(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(630);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Verification of a pattern using an OCV tool.
		///   Instance represents: Characters to be verified.
		/// </summary>
		/// <param name="OCVHandle">Handle of the OCV tool.</param>
		/// <param name="patternName">Name of the character. Default: "a"</param>
		/// <param name="adaptPos">Adaption to vertical and horizontal translation. Default: "true"</param>
		/// <param name="adaptSize">Adaption to vertical and horizontal scaling of the size. Default: "true"</param>
		/// <param name="adaptAngle">Adaption to changes of the orientation (not implemented). Default: "false"</param>
		/// <param name="adaptGray">Adaption to additive and scaling gray value changes. Default: "true"</param>
		/// <param name="threshold">Minimum difference between objects. Default: 10</param>
		/// <returns>Evaluation of the character.</returns>
		// Token: 0x06000735 RID: 1845 RVA: 0x0002C25C File Offset: 0x0002A45C
		public HTuple DoOcvSimple(HOCV OCVHandle, HTuple patternName, string adaptPos, string adaptSize, string adaptAngle, string adaptGray, double threshold)
		{
			IntPtr proc = HalconAPI.PreCall(638);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, OCVHandle);
			HalconAPI.Store(proc, 1, patternName);
			HalconAPI.StoreS(proc, 2, adaptPos);
			HalconAPI.StoreS(proc, 3, adaptSize);
			HalconAPI.StoreS(proc, 4, adaptAngle);
			HalconAPI.StoreS(proc, 5, adaptGray);
			HalconAPI.StoreD(proc, 6, threshold);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(patternName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(OCVHandle);
			return result;
		}

		/// <summary>
		///   Verification of a pattern using an OCV tool.
		///   Instance represents: Characters to be verified.
		/// </summary>
		/// <param name="OCVHandle">Handle of the OCV tool.</param>
		/// <param name="patternName">Name of the character. Default: "a"</param>
		/// <param name="adaptPos">Adaption to vertical and horizontal translation. Default: "true"</param>
		/// <param name="adaptSize">Adaption to vertical and horizontal scaling of the size. Default: "true"</param>
		/// <param name="adaptAngle">Adaption to changes of the orientation (not implemented). Default: "false"</param>
		/// <param name="adaptGray">Adaption to additive and scaling gray value changes. Default: "true"</param>
		/// <param name="threshold">Minimum difference between objects. Default: 10</param>
		/// <returns>Evaluation of the character.</returns>
		// Token: 0x06000736 RID: 1846 RVA: 0x0002C2F0 File Offset: 0x0002A4F0
		public double DoOcvSimple(HOCV OCVHandle, string patternName, string adaptPos, string adaptSize, string adaptAngle, string adaptGray, double threshold)
		{
			IntPtr proc = HalconAPI.PreCall(638);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, OCVHandle);
			HalconAPI.StoreS(proc, 1, patternName);
			HalconAPI.StoreS(proc, 2, adaptPos);
			HalconAPI.StoreS(proc, 3, adaptSize);
			HalconAPI.StoreS(proc, 4, adaptAngle);
			HalconAPI.StoreS(proc, 5, adaptGray);
			HalconAPI.StoreD(proc, 6, threshold);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(OCVHandle);
			return result;
		}

		/// <summary>
		///   Training of an OCV tool.
		///   Instance represents: Pattern to be trained.
		/// </summary>
		/// <param name="OCVHandle">Handle of the OCV tool to be trained.</param>
		/// <param name="name">Name(s) of the object(s) to analyse. Default: "a"</param>
		/// <param name="mode">Mode for training (only one mode implemented). Default: "single"</param>
		// Token: 0x06000737 RID: 1847 RVA: 0x0002C37C File Offset: 0x0002A57C
		public void TraindOcvProj(HOCV OCVHandle, HTuple name, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(639);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, OCVHandle);
			HalconAPI.Store(proc, 1, name);
			HalconAPI.StoreS(proc, 2, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(name);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(OCVHandle);
		}

		/// <summary>
		///   Training of an OCV tool.
		///   Instance represents: Pattern to be trained.
		/// </summary>
		/// <param name="OCVHandle">Handle of the OCV tool to be trained.</param>
		/// <param name="name">Name(s) of the object(s) to analyse. Default: "a"</param>
		/// <param name="mode">Mode for training (only one mode implemented). Default: "single"</param>
		// Token: 0x06000738 RID: 1848 RVA: 0x0002C3D4 File Offset: 0x0002A5D4
		public void TraindOcvProj(HOCV OCVHandle, string name, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(639);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, OCVHandle);
			HalconAPI.StoreS(proc, 1, name);
			HalconAPI.StoreS(proc, 2, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(OCVHandle);
		}

		/// <summary>
		///   Compute the features of a character.
		///   Instance represents: Input character.
		/// </summary>
		/// <param name="OCRHandle">Handle of the k-NN classifier.</param>
		/// <param name="transform">Should the feature vector be transformed with the preprocessing? Default: "true"</param>
		/// <returns>Feature vector of the character.</returns>
		// Token: 0x06000739 RID: 1849 RVA: 0x0002C428 File Offset: 0x0002A628
		public HTuple GetFeaturesOcrClassKnn(HOCRKnn OCRHandle, string transform)
		{
			IntPtr proc = HalconAPI.PreCall(656);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, transform);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Compute the features of a character.
		///   Instance represents: Input character.
		/// </summary>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="transform">Should the feature vector be transformed with the preprocessing? Default: "true"</param>
		/// <returns>Feature vector of the character.</returns>
		// Token: 0x0600073A RID: 1850 RVA: 0x0002C488 File Offset: 0x0002A688
		public HTuple GetFeaturesOcrClassSvm(HOCRSvm OCRHandle, string transform)
		{
			IntPtr proc = HalconAPI.PreCall(678);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, transform);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Compute the features of a character.
		///   Instance represents: Input character.
		/// </summary>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		/// <param name="transform">Should the feature vector be transformed with the preprocessing? Default: "true"</param>
		/// <returns>Feature vector of the character.</returns>
		// Token: 0x0600073B RID: 1851 RVA: 0x0002C4E8 File Offset: 0x0002A6E8
		public HTuple GetFeaturesOcrClassMlp(HOCRMlp OCRHandle, string transform)
		{
			IntPtr proc = HalconAPI.PreCall(696);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, OCRHandle);
			HalconAPI.StoreS(proc, 1, transform);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(OCRHandle);
			return result;
		}

		/// <summary>
		///   Cut out an image area relative to the domain.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="top">Number of rows clipped at the top. Default: -1</param>
		/// <param name="left">Number of columns clipped at the left. Default: -1</param>
		/// <param name="bottom">Number of rows clipped at the bottom. Default: -1</param>
		/// <param name="right">Number of columns clipped at the right. Default: -1</param>
		/// <returns>Image area.</returns>
		// Token: 0x0600073C RID: 1852 RVA: 0x0002C548 File Offset: 0x0002A748
		public HImage CropDomainRel(int top, int left, int bottom, int right)
		{
			IntPtr proc = HalconAPI.PreCall(726);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, top);
			HalconAPI.StoreI(proc, 1, left);
			HalconAPI.StoreI(proc, 2, bottom);
			HalconAPI.StoreI(proc, 3, right);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Access the features which correspond to a character.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="ocrHandle">ID of the desired OCR-classifier.</param>
		/// <returns>Feature vector.</returns>
		// Token: 0x0600073D RID: 1853 RVA: 0x0002C5B4 File Offset: 0x0002A7B4
		public HTuple OcrGetFeatures(HOCRBox ocrHandle)
		{
			IntPtr proc = HalconAPI.PreCall(727);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, ocrHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(ocrHandle);
			return result;
		}

		/// <summary>
		///   Write characters into a training file.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="classVal">Class (name) of the characters.</param>
		/// <param name="trainingFile">Name of the training file. Default: "train_ocr"</param>
		// Token: 0x0600073E RID: 1854 RVA: 0x0002C60C File Offset: 0x0002A80C
		public void WriteOcrTrainfImage(HTuple classVal, string trainingFile)
		{
			IntPtr proc = HalconAPI.PreCall(729);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, classVal);
			HalconAPI.StoreS(proc, 1, trainingFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(classVal);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write characters into a training file.
		///   Instance represents: Characters to be trained.
		/// </summary>
		/// <param name="classVal">Class (name) of the characters.</param>
		/// <param name="trainingFile">Name of the training file. Default: "train_ocr"</param>
		// Token: 0x0600073F RID: 1855 RVA: 0x0002C658 File Offset: 0x0002A858
		public void WriteOcrTrainfImage(string classVal, string trainingFile)
		{
			IntPtr proc = HalconAPI.PreCall(729);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, classVal);
			HalconAPI.StoreS(proc, 1, trainingFile);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read training specific characters from files and convert to images.
		///   Modified instance represents: Images read from file.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="searchNames">Names of the characters to be extracted. Default: "0"</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000740 RID: 1856 RVA: 0x0002C69C File Offset: 0x0002A89C
		public HTuple ReadOcrTrainfSelect(HTuple trainingFile, HTuple searchNames)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(733);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.Store(proc, 1, searchNames);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(searchNames);
			num = base.Load(proc, 1, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read training specific characters from files and convert to images.
		///   Modified instance represents: Images read from file.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="searchNames">Names of the characters to be extracted. Default: "0"</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000741 RID: 1857 RVA: 0x0002C710 File Offset: 0x0002A910
		public string ReadOcrTrainfSelect(string trainingFile, string searchNames)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(733);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.StoreS(proc, 1, searchNames);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read training characters from files and convert to images.
		///   Modified instance represents: Images read from file.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000742 RID: 1858 RVA: 0x0002C778 File Offset: 0x0002A978
		public HTuple ReadOcrTrainf(HTuple trainingFile)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(734);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			num = base.Load(proc, 1, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read training characters from files and convert to images.
		///   Modified instance represents: Images read from file.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <returns>Names of the read characters.</returns>
		// Token: 0x06000743 RID: 1859 RVA: 0x0002C7E0 File Offset: 0x0002A9E0
		public HTuple ReadOcrTrainf(string trainingFile)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(734);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a gray value bottom hat transformation on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="SE">Structuring element.</param>
		/// <returns>Bottom hat image.</returns>
		// Token: 0x06000744 RID: 1860 RVA: 0x0002C840 File Offset: 0x0002AA40
		public HImage GrayBothat(HImage SE)
		{
			IntPtr proc = HalconAPI.PreCall(780);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, SE);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(SE);
			return result;
		}

		/// <summary>
		///   Perform a gray value top hat transformation on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="SE">Structuring element.</param>
		/// <returns>Top hat image.</returns>
		// Token: 0x06000745 RID: 1861 RVA: 0x0002C898 File Offset: 0x0002AA98
		public HImage GrayTophat(HImage SE)
		{
			IntPtr proc = HalconAPI.PreCall(781);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, SE);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(SE);
			return result;
		}

		/// <summary>
		///   Perform a gray value closing on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="SE">Structuring element.</param>
		/// <returns>Gray-closed image.</returns>
		// Token: 0x06000746 RID: 1862 RVA: 0x0002C8F0 File Offset: 0x0002AAF0
		public HImage GrayClosing(HImage SE)
		{
			IntPtr proc = HalconAPI.PreCall(782);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, SE);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(SE);
			return result;
		}

		/// <summary>
		///   Perform a gray value opening on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="SE">Structuring element.</param>
		/// <returns>Gray-opened image.</returns>
		// Token: 0x06000747 RID: 1863 RVA: 0x0002C948 File Offset: 0x0002AB48
		public HImage GrayOpening(HImage SE)
		{
			IntPtr proc = HalconAPI.PreCall(783);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, SE);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(SE);
			return result;
		}

		/// <summary>
		///   Perform a gray value dilation on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="SE">Structuring element.</param>
		/// <returns>Gray-dilated image.</returns>
		// Token: 0x06000748 RID: 1864 RVA: 0x0002C9A0 File Offset: 0x0002ABA0
		public HImage GrayDilation(HImage SE)
		{
			IntPtr proc = HalconAPI.PreCall(784);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, SE);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(SE);
			return result;
		}

		/// <summary>
		///   Perform a gray value erosion on an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="SE">Structuring element.</param>
		/// <returns>Gray-eroded image.</returns>
		// Token: 0x06000749 RID: 1865 RVA: 0x0002C9F8 File Offset: 0x0002ABF8
		public HImage GrayErosion(HImage SE)
		{
			IntPtr proc = HalconAPI.PreCall(785);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, SE);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(SE);
			return result;
		}

		/// <summary>
		///   Load a structuring element for gray morphology.
		///   Modified instance represents: Generated structuring element.
		/// </summary>
		/// <param name="fileName">Name of the file containing the structuring element.</param>
		// Token: 0x0600074A RID: 1866 RVA: 0x0002CA50 File Offset: 0x0002AC50
		public void ReadGraySe(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(786);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate ellipsoidal structuring elements for gray morphology.
		///   Modified instance represents: Generated structuring element.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of the structuring element. Default: 5</param>
		/// <param name="height">Height of the structuring element. Default: 5</param>
		/// <param name="smax">Maximum gray value of the structuring element. Default: 0</param>
		// Token: 0x0600074B RID: 1867 RVA: 0x0002CA9C File Offset: 0x0002AC9C
		public void GenDiscSe(string type, int width, int height, HTuple smax)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(787);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.Store(proc, 3, smax);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(smax);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate ellipsoidal structuring elements for gray morphology.
		///   Modified instance represents: Generated structuring element.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="width">Width of the structuring element. Default: 5</param>
		/// <param name="height">Height of the structuring element. Default: 5</param>
		/// <param name="smax">Maximum gray value of the structuring element. Default: 0</param>
		// Token: 0x0600074C RID: 1868 RVA: 0x0002CB08 File Offset: 0x0002AD08
		public void GenDiscSe(string type, int width, int height, double smax)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(787);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			HalconAPI.StoreD(proc, 3, smax);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Extracting points with a particular gray value along a rectangle or an annular arc.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="measureHandle">Measure object handle.</param>
		/// <param name="sigma">Sigma of gaussian smoothing. Default: 1.0</param>
		/// <param name="threshold">Threshold. Default: 128.0</param>
		/// <param name="select">Selection of points. Default: "all"</param>
		/// <param name="rowThresh">Row coordinates of points with threshold value.</param>
		/// <param name="columnThresh">Column coordinates of points with threshold value.</param>
		/// <param name="distance">Distance between consecutive points.</param>
		// Token: 0x0600074D RID: 1869 RVA: 0x0002CB70 File Offset: 0x0002AD70
		public void MeasureThresh(HMeasure measureHandle, double sigma, double threshold, string select, out HTuple rowThresh, out HTuple columnThresh, out HTuple distance)
		{
			IntPtr proc = HalconAPI.PreCall(825);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, measureHandle);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.StoreS(proc, 3, select);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowThresh);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnThresh);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out distance);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(measureHandle);
		}

		/// <summary>
		///   Extract a gray value profile perpendicular to a rectangle or annular arc.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="measureHandle">Measure object handle.</param>
		/// <returns>Gray value profile.</returns>
		// Token: 0x0600074E RID: 1870 RVA: 0x0002CC08 File Offset: 0x0002AE08
		public HTuple MeasureProjection(HMeasure measureHandle)
		{
			IntPtr proc = HalconAPI.PreCall(828);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, measureHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(measureHandle);
			return result;
		}

		/// <summary>
		///   Extract straight edge pairs perpendicular to a rectangle or an annular arc.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="measureHandle">Measure object handle.</param>
		/// <param name="sigma">Sigma of Gaussian smoothing. Default: 1.0</param>
		/// <param name="ampThresh">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="fuzzyThresh">Minimum fuzzy value. Default: 0.5</param>
		/// <param name="transition">Select the first gray value transition of the edge pairs. Default: "all"</param>
		/// <param name="pairing">Constraint of pairing. Default: "no_restriction"</param>
		/// <param name="numPairs">Number of edge pairs. Default: 10</param>
		/// <param name="rowEdgeFirst">Row coordinate of the first edge.</param>
		/// <param name="columnEdgeFirst">Column coordinate of the first edge.</param>
		/// <param name="amplitudeFirst">Edge amplitude of the first edge (with sign).</param>
		/// <param name="rowEdgeSecond">Row coordinate of the second edge.</param>
		/// <param name="columnEdgeSecond">Column coordinate of the second edge.</param>
		/// <param name="amplitudeSecond">Edge amplitude of the second edge (with sign).</param>
		/// <param name="rowPairCenter">Row coordinate of the center of the edge pair.</param>
		/// <param name="columnPairCenter">Column coordinate of the center of the edge pair.</param>
		/// <param name="fuzzyScore">Fuzzy evaluation of the edge pair.</param>
		/// <param name="intraDistance">Distance between the edges of the edge pair.</param>
		// Token: 0x0600074F RID: 1871 RVA: 0x0002CC60 File Offset: 0x0002AE60
		public void FuzzyMeasurePairing(HMeasure measureHandle, double sigma, double ampThresh, double fuzzyThresh, string transition, string pairing, int numPairs, out HTuple rowEdgeFirst, out HTuple columnEdgeFirst, out HTuple amplitudeFirst, out HTuple rowEdgeSecond, out HTuple columnEdgeSecond, out HTuple amplitudeSecond, out HTuple rowPairCenter, out HTuple columnPairCenter, out HTuple fuzzyScore, out HTuple intraDistance)
		{
			IntPtr proc = HalconAPI.PreCall(832);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, measureHandle);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, ampThresh);
			HalconAPI.StoreD(proc, 3, fuzzyThresh);
			HalconAPI.StoreS(proc, 4, transition);
			HalconAPI.StoreS(proc, 5, pairing);
			HalconAPI.StoreI(proc, 6, numPairs);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowEdgeFirst);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnEdgeFirst);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out amplitudeFirst);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rowEdgeSecond);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out columnEdgeSecond);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out amplitudeSecond);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out rowPairCenter);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out columnPairCenter);
			num = HTuple.LoadNew(proc, 8, HTupleType.DOUBLE, num, out fuzzyScore);
			num = HTuple.LoadNew(proc, 9, HTupleType.DOUBLE, num, out intraDistance);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(measureHandle);
		}

		/// <summary>
		///   Extract straight edge pairs perpendicular to a rectangle or an annular arc.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="measureHandle">Measure object handle.</param>
		/// <param name="sigma">Sigma of Gaussian smoothing. Default: 1.0</param>
		/// <param name="ampThresh">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="fuzzyThresh">Minimum fuzzy value. Default: 0.5</param>
		/// <param name="transition">Select the first gray value transition of the edge pairs. Default: "all"</param>
		/// <param name="rowEdgeFirst">Row coordinate of the first edge point.</param>
		/// <param name="columnEdgeFirst">Column coordinate of the first edge point.</param>
		/// <param name="amplitudeFirst">Edge amplitude of the first edge (with sign).</param>
		/// <param name="rowEdgeSecond">Row coordinate of the second edge point.</param>
		/// <param name="columnEdgeSecond">Column coordinate of the second edge point.</param>
		/// <param name="amplitudeSecond">Edge amplitude of the second edge (with sign).</param>
		/// <param name="rowEdgeCenter">Row coordinate of the center of the edge pair.</param>
		/// <param name="columnEdgeCenter">Column coordinate of the center of the edge pair.</param>
		/// <param name="fuzzyScore">Fuzzy evaluation of the edge pair.</param>
		/// <param name="intraDistance">Distance between edges of an edge pair.</param>
		/// <param name="interDistance">Distance between consecutive edge pairs.</param>
		// Token: 0x06000750 RID: 1872 RVA: 0x0002CDA0 File Offset: 0x0002AFA0
		public void FuzzyMeasurePairs(HMeasure measureHandle, double sigma, double ampThresh, double fuzzyThresh, string transition, out HTuple rowEdgeFirst, out HTuple columnEdgeFirst, out HTuple amplitudeFirst, out HTuple rowEdgeSecond, out HTuple columnEdgeSecond, out HTuple amplitudeSecond, out HTuple rowEdgeCenter, out HTuple columnEdgeCenter, out HTuple fuzzyScore, out HTuple intraDistance, out HTuple interDistance)
		{
			IntPtr proc = HalconAPI.PreCall(833);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, measureHandle);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, ampThresh);
			HalconAPI.StoreD(proc, 3, fuzzyThresh);
			HalconAPI.StoreS(proc, 4, transition);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			HalconAPI.InitOCT(proc, 10);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowEdgeFirst);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnEdgeFirst);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out amplitudeFirst);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rowEdgeSecond);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out columnEdgeSecond);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out amplitudeSecond);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out rowEdgeCenter);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out columnEdgeCenter);
			num = HTuple.LoadNew(proc, 8, HTupleType.DOUBLE, num, out fuzzyScore);
			num = HTuple.LoadNew(proc, 9, HTupleType.DOUBLE, num, out intraDistance);
			num = HTuple.LoadNew(proc, 10, HTupleType.DOUBLE, num, out interDistance);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(measureHandle);
		}

		/// <summary>
		///   Extract straight edges perpendicular to a rectangle or an annular arc.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="measureHandle">Measure object handle.</param>
		/// <param name="sigma">Sigma of Gaussian smoothing. Default: 1.0</param>
		/// <param name="ampThresh">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="fuzzyThresh">Minimum fuzzy value. Default: 0.5</param>
		/// <param name="transition">Select light/dark or dark/light edges. Default: "all"</param>
		/// <param name="rowEdge">Row coordinate of the edge point.</param>
		/// <param name="columnEdge">Column coordinate of the edge point.</param>
		/// <param name="amplitude">Edge amplitude of the edge (with sign).</param>
		/// <param name="fuzzyScore">Fuzzy evaluation of the edges.</param>
		/// <param name="distance">Distance between consecutive edges.</param>
		// Token: 0x06000751 RID: 1873 RVA: 0x0002CEE4 File Offset: 0x0002B0E4
		public void FuzzyMeasurePos(HMeasure measureHandle, double sigma, double ampThresh, double fuzzyThresh, string transition, out HTuple rowEdge, out HTuple columnEdge, out HTuple amplitude, out HTuple fuzzyScore, out HTuple distance)
		{
			IntPtr proc = HalconAPI.PreCall(834);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, measureHandle);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, ampThresh);
			HalconAPI.StoreD(proc, 3, fuzzyThresh);
			HalconAPI.StoreS(proc, 4, transition);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowEdge);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnEdge);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out amplitude);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out fuzzyScore);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out distance);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(measureHandle);
		}

		/// <summary>
		///   Extract straight edge pairs perpendicular to a rectangle or annular arc.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="measureHandle">Measure object handle.</param>
		/// <param name="sigma">Sigma of gaussian smoothing. Default: 1.0</param>
		/// <param name="threshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="transition">Type of gray value transition that determines how edges are grouped to edge pairs. Default: "all"</param>
		/// <param name="select">Selection of edge pairs. Default: "all"</param>
		/// <param name="rowEdgeFirst">Row coordinate of the center of the first edge.</param>
		/// <param name="columnEdgeFirst">Column coordinate of the center of the first edge.</param>
		/// <param name="amplitudeFirst">Edge amplitude of the first edge (with sign).</param>
		/// <param name="rowEdgeSecond">Row coordinate of the center of the second edge.</param>
		/// <param name="columnEdgeSecond">Column coordinate of the center of the second edge.</param>
		/// <param name="amplitudeSecond">Edge amplitude of the second edge (with sign).</param>
		/// <param name="intraDistance">Distance between edges of an edge pair.</param>
		/// <param name="interDistance">Distance between consecutive edge pairs.</param>
		// Token: 0x06000752 RID: 1874 RVA: 0x0002CFAC File Offset: 0x0002B1AC
		public void MeasurePairs(HMeasure measureHandle, double sigma, double threshold, string transition, string select, out HTuple rowEdgeFirst, out HTuple columnEdgeFirst, out HTuple amplitudeFirst, out HTuple rowEdgeSecond, out HTuple columnEdgeSecond, out HTuple amplitudeSecond, out HTuple intraDistance, out HTuple interDistance)
		{
			IntPtr proc = HalconAPI.PreCall(835);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, measureHandle);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.StoreS(proc, 3, transition);
			HalconAPI.StoreS(proc, 4, select);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowEdgeFirst);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnEdgeFirst);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out amplitudeFirst);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rowEdgeSecond);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out columnEdgeSecond);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out amplitudeSecond);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out intraDistance);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out interDistance);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(measureHandle);
		}

		/// <summary>
		///   Extract straight edges perpendicular to a rectangle or annular arc.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="measureHandle">Measure object handle.</param>
		/// <param name="sigma">Sigma of gaussian smoothing. Default: 1.0</param>
		/// <param name="threshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="transition">Light/dark or dark/light edge. Default: "all"</param>
		/// <param name="select">Selection of end points. Default: "all"</param>
		/// <param name="rowEdge">Row coordinate of the center of the edge.</param>
		/// <param name="columnEdge">Column coordinate of the center of the edge.</param>
		/// <param name="amplitude">Edge amplitude of the edge (with sign).</param>
		/// <param name="distance">Distance between consecutive edges.</param>
		// Token: 0x06000753 RID: 1875 RVA: 0x0002D0B0 File Offset: 0x0002B2B0
		public void MeasurePos(HMeasure measureHandle, double sigma, double threshold, string transition, string select, out HTuple rowEdge, out HTuple columnEdge, out HTuple amplitude, out HTuple distance)
		{
			IntPtr proc = HalconAPI.PreCall(836);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, measureHandle);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.StoreS(proc, 3, transition);
			HalconAPI.StoreS(proc, 4, select);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowEdge);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnEdge);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out amplitude);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out distance);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(measureHandle);
		}

		/// <summary>
		///   Identify objects with a sample identifier. 
		///   Instance represents: Image showing the object to be identified.
		/// </summary>
		/// <param name="sampleIdentifier">Handle of the sample identifier.</param>
		/// <param name="numResults">Number of suggested object indices. Default: 1</param>
		/// <param name="ratingThreshold">Rating threshold. Default: 0.0</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <param name="rating">Rating value of the identified object.</param>
		/// <returns>Index of the identified object.</returns>
		// Token: 0x06000754 RID: 1876 RVA: 0x0002D164 File Offset: 0x0002B364
		public HTuple ApplySampleIdentifier(HSampleIdentifier sampleIdentifier, int numResults, double ratingThreshold, HTuple genParamName, HTuple genParamValue, out HTuple rating)
		{
			IntPtr proc = HalconAPI.PreCall(904);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sampleIdentifier);
			HalconAPI.StoreI(proc, 1, numResults);
			HalconAPI.StoreD(proc, 2, ratingThreshold);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rating);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sampleIdentifier);
			return result;
		}

		/// <summary>
		///   Identify objects with a sample identifier. 
		///   Instance represents: Image showing the object to be identified.
		/// </summary>
		/// <param name="sampleIdentifier">Handle of the sample identifier.</param>
		/// <param name="numResults">Number of suggested object indices. Default: 1</param>
		/// <param name="ratingThreshold">Rating threshold. Default: 0.0</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <param name="rating">Rating value of the identified object.</param>
		/// <returns>Index of the identified object.</returns>
		// Token: 0x06000755 RID: 1877 RVA: 0x0002D200 File Offset: 0x0002B400
		public int ApplySampleIdentifier(HSampleIdentifier sampleIdentifier, int numResults, double ratingThreshold, HTuple genParamName, HTuple genParamValue, out double rating)
		{
			IntPtr proc = HalconAPI.PreCall(904);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sampleIdentifier);
			HalconAPI.StoreI(proc, 1, numResults);
			HalconAPI.StoreD(proc, 2, ratingThreshold);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out rating);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sampleIdentifier);
			return result;
		}

		/// <summary>
		///   Add training data to an existing sample identifier. 
		///   Instance represents: Image that shows an object.
		/// </summary>
		/// <param name="sampleIdentifier">Handle of the sample identifier.</param>
		/// <param name="objectIdx">Index of the object visible in the SampleImage.</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <returns>Index of the object sample.</returns>
		// Token: 0x06000756 RID: 1878 RVA: 0x0002D29C File Offset: 0x0002B49C
		public int AddSampleIdentifierTrainingData(HSampleIdentifier sampleIdentifier, HTuple objectIdx, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(912);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sampleIdentifier);
			HalconAPI.Store(proc, 1, objectIdx);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(objectIdx);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sampleIdentifier);
			return result;
		}

		/// <summary>
		///   Add training data to an existing sample identifier. 
		///   Instance represents: Image that shows an object.
		/// </summary>
		/// <param name="sampleIdentifier">Handle of the sample identifier.</param>
		/// <param name="objectIdx">Index of the object visible in the SampleImage.</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <returns>Index of the object sample.</returns>
		// Token: 0x06000757 RID: 1879 RVA: 0x0002D320 File Offset: 0x0002B520
		public int AddSampleIdentifierTrainingData(HSampleIdentifier sampleIdentifier, int objectIdx, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(912);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sampleIdentifier);
			HalconAPI.StoreI(proc, 1, objectIdx);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sampleIdentifier);
			return result;
		}

		/// <summary>
		///   Add preparation data to an existing sample identifier. 
		///   Instance represents: Image that shows an object.
		/// </summary>
		/// <param name="sampleIdentifier">Handle of the sample identifier.</param>
		/// <param name="objectIdx">Index of the object visible in the SampleImage. Default: "unknown"</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <returns>Index of the object sample.</returns>
		// Token: 0x06000758 RID: 1880 RVA: 0x0002D39C File Offset: 0x0002B59C
		public int AddSampleIdentifierPreparationData(HSampleIdentifier sampleIdentifier, HTuple objectIdx, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(914);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sampleIdentifier);
			HalconAPI.Store(proc, 1, objectIdx);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(objectIdx);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sampleIdentifier);
			return result;
		}

		/// <summary>
		///   Add preparation data to an existing sample identifier. 
		///   Instance represents: Image that shows an object.
		/// </summary>
		/// <param name="sampleIdentifier">Handle of the sample identifier.</param>
		/// <param name="objectIdx">Index of the object visible in the SampleImage. Default: "unknown"</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <returns>Index of the object sample.</returns>
		// Token: 0x06000759 RID: 1881 RVA: 0x0002D420 File Offset: 0x0002B620
		public int AddSampleIdentifierPreparationData(HSampleIdentifier sampleIdentifier, int objectIdx, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(914);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sampleIdentifier);
			HalconAPI.StoreI(proc, 1, objectIdx);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sampleIdentifier);
			return result;
		}

		/// <summary>
		///   Determine the parameters of a shape model.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="optimization">Kind of optimization. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="parameters">Parameters to be determined automatically. Default: "all"</param>
		/// <param name="parameterValue">Value of the automatically determined parameter.</param>
		/// <returns>Name of the automatically determined parameter.</returns>
		// Token: 0x0600075A RID: 1882 RVA: 0x0002D49C File Offset: 0x0002B69C
		public HTuple DetermineShapeModelParams(HTuple numLevels, double angleStart, double angleExtent, HTuple scaleMin, HTuple scaleMax, string optimization, string metric, HTuple contrast, HTuple minContrast, HTuple parameters, out HTuple parameterValue)
		{
			IntPtr proc = HalconAPI.PreCall(923);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, scaleMin);
			HalconAPI.Store(proc, 4, scaleMax);
			HalconAPI.StoreS(proc, 5, optimization);
			HalconAPI.StoreS(proc, 6, metric);
			HalconAPI.Store(proc, 7, contrast);
			HalconAPI.Store(proc, 8, minContrast);
			HalconAPI.Store(proc, 9, parameters);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(scaleMin);
			HalconAPI.UnpinTuple(scaleMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(parameters);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out parameterValue);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the parameters of a shape model.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="optimization">Kind of optimization. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="parameters">Parameters to be determined automatically. Default: "all"</param>
		/// <param name="parameterValue">Value of the automatically determined parameter.</param>
		/// <returns>Name of the automatically determined parameter.</returns>
		// Token: 0x0600075B RID: 1883 RVA: 0x0002D578 File Offset: 0x0002B778
		public HTuple DetermineShapeModelParams(int numLevels, double angleStart, double angleExtent, double scaleMin, double scaleMax, string optimization, string metric, int contrast, int minContrast, string parameters, out HTuple parameterValue)
		{
			IntPtr proc = HalconAPI.PreCall(923);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.StoreS(proc, 5, optimization);
			HalconAPI.StoreS(proc, 6, metric);
			HalconAPI.StoreI(proc, 7, contrast);
			HalconAPI.StoreI(proc, 8, minContrast);
			HalconAPI.StoreS(proc, 9, parameters);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out parameterValue);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find the best matches of multiple anisotropically scaled shape models.
		///   Instance represents: Input image in which the models should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the models in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the models in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the models in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the models in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scaleR">Scale of the found instances of the models in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the models in the column direction.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x0600075C RID: 1884 RVA: 0x0002D62C File Offset: 0x0002B82C
		public void FindAnisoShapeModels(HShapeModel[] modelIDs, HTuple angleStart, HTuple angleExtent, HTuple scaleRMin, HTuple scaleRMax, HTuple scaleCMin, HTuple scaleCMax, HTuple minScore, HTuple numMatches, HTuple maxOverlap, HTuple subPixel, HTuple numLevels, HTuple greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score, out HTuple model)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelIDs);
			IntPtr proc = HalconAPI.PreCall(927);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, scaleRMin);
			HalconAPI.Store(proc, 4, scaleRMax);
			HalconAPI.Store(proc, 5, scaleCMin);
			HalconAPI.Store(proc, 6, scaleCMax);
			HalconAPI.Store(proc, 7, minScore);
			HalconAPI.Store(proc, 8, numMatches);
			HalconAPI.Store(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, subPixel);
			HalconAPI.Store(proc, 11, numLevels);
			HalconAPI.Store(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMin);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMin);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(numMatches);
			HalconAPI.UnpinTuple(maxOverlap);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(greediness);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple anisotropically scaled shape models.
		///   Instance represents: Input image in which the models should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the models in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the models in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the models in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the models in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scaleR">Scale of the found instances of the models in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the models in the column direction.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x0600075D RID: 1885 RVA: 0x0002D7CC File Offset: 0x0002B9CC
		public void FindAnisoShapeModels(HShapeModel modelIDs, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score, out HTuple model)
		{
			IntPtr proc = HalconAPI.PreCall(927);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelIDs);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreS(proc, 10, subPixel);
			HalconAPI.StoreI(proc, 11, numLevels);
			HalconAPI.StoreD(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 6, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple isotropically scaled shape models.
		///   Instance represents: Input image in which the models should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the models. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the models. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scale">Scale of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x0600075E RID: 1886 RVA: 0x0002D908 File Offset: 0x0002BB08
		public void FindScaledShapeModels(HShapeModel[] modelIDs, HTuple angleStart, HTuple angleExtent, HTuple scaleMin, HTuple scaleMax, HTuple minScore, HTuple numMatches, HTuple maxOverlap, HTuple subPixel, HTuple numLevels, HTuple greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score, out HTuple model)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelIDs);
			IntPtr proc = HalconAPI.PreCall(928);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, scaleMin);
			HalconAPI.Store(proc, 4, scaleMax);
			HalconAPI.Store(proc, 5, minScore);
			HalconAPI.Store(proc, 6, numMatches);
			HalconAPI.Store(proc, 7, maxOverlap);
			HalconAPI.Store(proc, 8, subPixel);
			HalconAPI.Store(proc, 9, numLevels);
			HalconAPI.Store(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleMin);
			HalconAPI.UnpinTuple(scaleMax);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(numMatches);
			HalconAPI.UnpinTuple(maxOverlap);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(greediness);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple isotropically scaled shape models.
		///   Instance represents: Input image in which the models should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the models. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the models. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="scale">Scale of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x0600075F RID: 1887 RVA: 0x0002DA70 File Offset: 0x0002BC70
		public void FindScaledShapeModels(HShapeModel modelIDs, double angleStart, double angleExtent, double scaleMin, double scaleMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score, out HTuple model)
		{
			IntPtr proc = HalconAPI.PreCall(928);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelIDs);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.StoreD(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.StoreD(proc, 7, maxOverlap);
			HalconAPI.StoreS(proc, 8, subPixel);
			HalconAPI.StoreI(proc, 9, numLevels);
			HalconAPI.StoreD(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 5, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple shape models.
		///   Instance represents: Input image in which the models should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x06000760 RID: 1888 RVA: 0x0002DB84 File Offset: 0x0002BD84
		public void FindShapeModels(HShapeModel[] modelIDs, HTuple angleStart, HTuple angleExtent, HTuple minScore, HTuple numMatches, HTuple maxOverlap, HTuple subPixel, HTuple numLevels, HTuple greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score, out HTuple model)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelIDs);
			IntPtr proc = HalconAPI.PreCall(929);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.Store(proc, 4, numMatches);
			HalconAPI.Store(proc, 5, maxOverlap);
			HalconAPI.Store(proc, 6, subPixel);
			HalconAPI.Store(proc, 7, numLevels);
			HalconAPI.Store(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(numMatches);
			HalconAPI.UnpinTuple(maxOverlap);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(greediness);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple shape models.
		///   Instance represents: Input image in which the models should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x06000761 RID: 1889 RVA: 0x0002DCB8 File Offset: 0x0002BEB8
		public void FindShapeModels(HShapeModel modelIDs, double angleStart, double angleExtent, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score, out HTuple model)
		{
			IntPtr proc = HalconAPI.PreCall(929);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelIDs);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, subPixel);
			HalconAPI.StoreI(proc, 7, numLevels);
			HalconAPI.StoreD(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of an anisotropically scaled shape model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the model in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the model in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the model in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the model in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scaleR">Scale of the found instances of the model in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the model in the column direction.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000762 RID: 1890 RVA: 0x0002DDA4 File Offset: 0x0002BFA4
		public void FindAnisoShapeModel(HShapeModel modelID, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, HTuple minScore, int numMatches, double maxOverlap, HTuple subPixel, HTuple numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(930);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.Store(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, subPixel);
			HalconAPI.Store(proc, 11, numLevels);
			HalconAPI.StoreD(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Find the best matches of an anisotropically scaled shape model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the model in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the model in the row direction. Default: 1.1</param>
		/// <param name="scaleCMin">Minimum scale of the model in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the model in the column direction. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scaleR">Scale of the found instances of the model in the row direction.</param>
		/// <param name="scaleC">Scale of the found instances of the model in the column direction.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000763 RID: 1891 RVA: 0x0002DEE4 File Offset: 0x0002C0E4
		public void FindAnisoShapeModel(HShapeModel modelID, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scaleR, out HTuple scaleC, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(930);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreS(proc, 10, subPixel);
			HalconAPI.StoreI(proc, 11, numLevels);
			HalconAPI.StoreD(proc, 12, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scaleR);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out scaleC);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Find the best matches of an isotropically scaled shape model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scale">Scale of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000764 RID: 1892 RVA: 0x0002E00C File Offset: 0x0002C20C
		public void FindScaledShapeModel(HShapeModel modelID, double angleStart, double angleExtent, double scaleMin, double scaleMax, HTuple minScore, int numMatches, double maxOverlap, HTuple subPixel, HTuple numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(931);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.Store(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.StoreD(proc, 7, maxOverlap);
			HalconAPI.Store(proc, 8, subPixel);
			HalconAPI.Store(proc, 9, numLevels);
			HalconAPI.StoreD(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Find the best matches of an isotropically scaled shape model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="scale">Scale of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000765 RID: 1893 RVA: 0x0002E124 File Offset: 0x0002C324
		public void FindScaledShapeModel(HShapeModel modelID, double angleStart, double angleExtent, double scaleMin, double scaleMax, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple scale, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(931);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.StoreD(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.StoreD(proc, 7, maxOverlap);
			HalconAPI.StoreS(proc, 8, subPixel);
			HalconAPI.StoreI(proc, 9, numLevels);
			HalconAPI.StoreD(proc, 10, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out scale);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Find the best matches of a shape model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000766 RID: 1894 RVA: 0x0002E224 File Offset: 0x0002C424
		public void FindShapeModel(HShapeModel modelID, double angleStart, double angleExtent, HTuple minScore, int numMatches, double maxOverlap, HTuple subPixel, HTuple numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(932);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.Store(proc, 6, subPixel);
			HalconAPI.Store(proc, 7, numLevels);
			HalconAPI.StoreD(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Find the best matches of a shape model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000767 RID: 1895 RVA: 0x0002E314 File Offset: 0x0002C514
		public void FindShapeModel(HShapeModel modelID, double angleStart, double angleExtent, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, double greediness, out HTuple row, out HTuple column, out HTuple angle, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(932);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, subPixel);
			HalconAPI.StoreI(proc, 7, numLevels);
			HalconAPI.StoreD(proc, 8, greediness);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Set the metric of a shape model that was created from XLD contours.
		///   Instance represents: Input image used for the determination of the polarity.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x06000768 RID: 1896 RVA: 0x0002E3EC File Offset: 0x0002C5EC
		public void SetShapeModelMetric(HShapeModel modelID, HHomMat2D homMat2D, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(933);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreS(proc, 2, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>Set selected parameters of the shape model.</summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x06000769 RID: 1897 RVA: 0x0002E450 File Offset: 0x0002C650
		public static void SetShapeModelParam(HShapeModel modelID, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(934);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600076A RID: 1898 RVA: 0x0002E4A0 File Offset: 0x0002C6A0
		public HShapeModel CreateAnisoShapeModel(HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleRMin, double scaleRMax, HTuple scaleRStep, double scaleCMin, double scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(938);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600076B RID: 1899 RVA: 0x0002E598 File Offset: 0x0002C798
		public HShapeModel CreateAnisoShapeModel(int numLevels, double angleStart, double angleExtent, double angleStep, double scaleRMin, double scaleRMax, double scaleRStep, double scaleCMin, double scaleCMax, double scaleCStep, string optimization, string metric, int contrast, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(938);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600076C RID: 1900 RVA: 0x0002E660 File Offset: 0x0002C860
		public HShapeModel CreateScaledShapeModel(HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleMin, double scaleMax, HTuple scaleStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(939);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.Store(proc, 6, scaleStep);
			HalconAPI.Store(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.Store(proc, 9, contrast);
			HalconAPI.Store(proc, 10, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600076D RID: 1901 RVA: 0x0002E734 File Offset: 0x0002C934
		public HShapeModel CreateScaledShapeModel(int numLevels, double angleStart, double angleExtent, double angleStep, double scaleMin, double scaleMax, double scaleStep, string optimization, string metric, int contrast, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(939);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.StoreD(proc, 6, scaleStep);
			HalconAPI.StoreS(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, contrast);
			HalconAPI.StoreI(proc, 10, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a shape model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600076E RID: 1902 RVA: 0x0002E7E0 File Offset: 0x0002C9E0
		public HShapeModel CreateShapeModel(HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(940);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.Store(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.Store(proc, 6, contrast);
			HalconAPI.Store(proc, 7, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a shape model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600076F RID: 1903 RVA: 0x0002E890 File Offset: 0x0002CA90
		public HShapeModel CreateShapeModel(int numLevels, double angleStart, double angleExtent, double angleStep, string optimization, string metric, int contrast, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(940);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, contrast);
			HalconAPI.StoreI(proc, 7, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create the representation of a shape model.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="modelRegions">Model region pyramid</param>
		/// <param name="numLevels">Number of pyramid levels. Default: 4</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the image and optionally minimum size of the object parts. Default: 30</param>
		/// <returns>Image pyramid of the input image</returns>
		// Token: 0x06000770 RID: 1904 RVA: 0x0002E920 File Offset: 0x0002CB20
		public HImage InspectShapeModel(out HRegion modelRegions, int numLevels, HTuple contrast)
		{
			IntPtr proc = HalconAPI.PreCall(941);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, contrast);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(contrast);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out modelRegions);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create the representation of a shape model.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="modelRegions">Model region pyramid</param>
		/// <param name="numLevels">Number of pyramid levels. Default: 4</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the image and optionally minimum size of the object parts. Default: 30</param>
		/// <returns>Image pyramid of the input image</returns>
		// Token: 0x06000771 RID: 1905 RVA: 0x0002E990 File Offset: 0x0002CB90
		public HImage InspectShapeModel(out HRegion modelRegions, int numLevels, int contrast)
		{
			IntPtr proc = HalconAPI.PreCall(941);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreI(proc, 1, contrast);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out modelRegions);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find the best matches of a calibrated descriptor model in an image and return their 3D pose.
		///   Instance represents: Input image where the model should be found.
		/// </summary>
		/// <param name="modelID">The handle to the descriptor model.</param>
		/// <param name="detectorParamName">The detector's parameter names. Default: []</param>
		/// <param name="detectorParamValue">Values of the detector's parameters. Default: []</param>
		/// <param name="descriptorParamName">The descriptor's parameter names. Default: []</param>
		/// <param name="descriptorParamValue">Values of the descriptor's parameters. Default: []</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.2</param>
		/// <param name="numMatches">Maximal number of found instances. Default: 1</param>
		/// <param name="camParam">Camera parameter (inner orientation) obtained from camera calibration.</param>
		/// <param name="scoreType">Score type to be evaluated in Score. Default: "num_points"</param>
		/// <param name="score">Score of the found instances according to the ScoreType input.</param>
		/// <returns>3D pose of the object.</returns>
		// Token: 0x06000772 RID: 1906 RVA: 0x0002E9FC File Offset: 0x0002CBFC
		public HPose[] FindCalibDescriptorModel(HDescriptorModel modelID, HTuple detectorParamName, HTuple detectorParamValue, HTuple descriptorParamName, HTuple descriptorParamValue, HTuple minScore, int numMatches, HCamPar camParam, HTuple scoreType, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(948);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, detectorParamName);
			HalconAPI.Store(proc, 2, detectorParamValue);
			HalconAPI.Store(proc, 3, descriptorParamName);
			HalconAPI.Store(proc, 4, descriptorParamValue);
			HalconAPI.Store(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.Store(proc, 7, camParam);
			HalconAPI.Store(proc, 8, scoreType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(detectorParamName);
			HalconAPI.UnpinTuple(detectorParamValue);
			HalconAPI.UnpinTuple(descriptorParamName);
			HalconAPI.UnpinTuple(descriptorParamValue);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(scoreType);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, num, out score);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a calibrated descriptor model in an image and return their 3D pose.
		///   Instance represents: Input image where the model should be found.
		/// </summary>
		/// <param name="modelID">The handle to the descriptor model.</param>
		/// <param name="detectorParamName">The detector's parameter names. Default: []</param>
		/// <param name="detectorParamValue">Values of the detector's parameters. Default: []</param>
		/// <param name="descriptorParamName">The descriptor's parameter names. Default: []</param>
		/// <param name="descriptorParamValue">Values of the descriptor's parameters. Default: []</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.2</param>
		/// <param name="numMatches">Maximal number of found instances. Default: 1</param>
		/// <param name="camParam">Camera parameter (inner orientation) obtained from camera calibration.</param>
		/// <param name="scoreType">Score type to be evaluated in Score. Default: "num_points"</param>
		/// <param name="score">Score of the found instances according to the ScoreType input.</param>
		/// <returns>3D pose of the object.</returns>
		// Token: 0x06000773 RID: 1907 RVA: 0x0002EAEC File Offset: 0x0002CCEC
		public HPose FindCalibDescriptorModel(HDescriptorModel modelID, HTuple detectorParamName, HTuple detectorParamValue, HTuple descriptorParamName, HTuple descriptorParamValue, double minScore, int numMatches, HCamPar camParam, string scoreType, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(948);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, detectorParamName);
			HalconAPI.Store(proc, 2, detectorParamValue);
			HalconAPI.Store(proc, 3, descriptorParamName);
			HalconAPI.Store(proc, 4, descriptorParamValue);
			HalconAPI.StoreD(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.Store(proc, 7, camParam);
			HalconAPI.StoreS(proc, 8, scoreType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(detectorParamName);
			HalconAPI.UnpinTuple(detectorParamValue);
			HalconAPI.UnpinTuple(descriptorParamName);
			HalconAPI.UnpinTuple(descriptorParamValue);
			HalconAPI.UnpinTuple(camParam);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a descriptor model in an image.
		///   Instance represents: Input image where the model should be found.
		/// </summary>
		/// <param name="modelID">The handle to the descriptor model.</param>
		/// <param name="detectorParamName">The detector's parameter names. Default: []</param>
		/// <param name="detectorParamValue">Values of the detector's parameters. Default: []</param>
		/// <param name="descriptorParamName">The descriptor's parameter names. Default: []</param>
		/// <param name="descriptorParamValue">Values of the descriptor's parameters. Default: []</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.2</param>
		/// <param name="numMatches">Maximal number of found instances. Default: 1</param>
		/// <param name="scoreType">Score type to be evaluated in Score. Default: "num_points"</param>
		/// <param name="score">Score of the found instances according to the ScoreType input.</param>
		/// <returns>Homography between model and found instance.</returns>
		// Token: 0x06000774 RID: 1908 RVA: 0x0002EBC8 File Offset: 0x0002CDC8
		public HHomMat2D[] FindUncalibDescriptorModel(HDescriptorModel modelID, HTuple detectorParamName, HTuple detectorParamValue, HTuple descriptorParamName, HTuple descriptorParamValue, HTuple minScore, int numMatches, HTuple scoreType, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(949);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, detectorParamName);
			HalconAPI.Store(proc, 2, detectorParamValue);
			HalconAPI.Store(proc, 3, descriptorParamName);
			HalconAPI.Store(proc, 4, descriptorParamValue);
			HalconAPI.Store(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.Store(proc, 7, scoreType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(detectorParamName);
			HalconAPI.UnpinTuple(detectorParamValue);
			HalconAPI.UnpinTuple(descriptorParamName);
			HalconAPI.UnpinTuple(descriptorParamValue);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(scoreType);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, num, out score);
			HalconAPI.PostCall(proc, num);
			HHomMat2D[] result = HHomMat2D.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a descriptor model in an image.
		///   Instance represents: Input image where the model should be found.
		/// </summary>
		/// <param name="modelID">The handle to the descriptor model.</param>
		/// <param name="detectorParamName">The detector's parameter names. Default: []</param>
		/// <param name="detectorParamValue">Values of the detector's parameters. Default: []</param>
		/// <param name="descriptorParamName">The descriptor's parameter names. Default: []</param>
		/// <param name="descriptorParamValue">Values of the descriptor's parameters. Default: []</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.2</param>
		/// <param name="numMatches">Maximal number of found instances. Default: 1</param>
		/// <param name="scoreType">Score type to be evaluated in Score. Default: "num_points"</param>
		/// <param name="score">Score of the found instances according to the ScoreType input.</param>
		/// <returns>Homography between model and found instance.</returns>
		// Token: 0x06000775 RID: 1909 RVA: 0x0002EC9C File Offset: 0x0002CE9C
		public HHomMat2D FindUncalibDescriptorModel(HDescriptorModel modelID, HTuple detectorParamName, HTuple detectorParamValue, HTuple descriptorParamName, HTuple descriptorParamValue, double minScore, int numMatches, string scoreType, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(949);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, detectorParamName);
			HalconAPI.Store(proc, 2, detectorParamValue);
			HalconAPI.Store(proc, 3, descriptorParamName);
			HalconAPI.Store(proc, 4, descriptorParamValue);
			HalconAPI.StoreD(proc, 5, minScore);
			HalconAPI.StoreI(proc, 6, numMatches);
			HalconAPI.StoreS(proc, 7, scoreType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(detectorParamName);
			HalconAPI.UnpinTuple(detectorParamValue);
			HalconAPI.UnpinTuple(descriptorParamName);
			HalconAPI.UnpinTuple(descriptorParamValue);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Create a descriptor model for calibrated perspective matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object in the reference image.</param>
		/// <param name="detectorType">The type of the detector. Default: "lepetit"</param>
		/// <param name="detectorParamName">The detector's parameter names. Default: []</param>
		/// <param name="detectorParamValue">Values of the detector's parameters. Default: []</param>
		/// <param name="descriptorParamName">The descriptor's parameter names. Default: []</param>
		/// <param name="descriptorParamValue">Values of the descriptor's parameters. Default: []</param>
		/// <param name="seed">The seed for the random number generator. Default: 42</param>
		/// <returns>The handle to the descriptor model.</returns>
		// Token: 0x06000776 RID: 1910 RVA: 0x0002ED5C File Offset: 0x0002CF5C
		public HDescriptorModel CreateCalibDescriptorModel(HCamPar camParam, HPose referencePose, string detectorType, HTuple detectorParamName, HTuple detectorParamValue, HTuple descriptorParamName, HTuple descriptorParamValue, int seed)
		{
			IntPtr proc = HalconAPI.PreCall(952);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.StoreS(proc, 2, detectorType);
			HalconAPI.Store(proc, 3, detectorParamName);
			HalconAPI.Store(proc, 4, detectorParamValue);
			HalconAPI.Store(proc, 5, descriptorParamName);
			HalconAPI.Store(proc, 6, descriptorParamValue);
			HalconAPI.StoreI(proc, 7, seed);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(detectorParamName);
			HalconAPI.UnpinTuple(detectorParamValue);
			HalconAPI.UnpinTuple(descriptorParamName);
			HalconAPI.UnpinTuple(descriptorParamValue);
			HDescriptorModel result;
			num = HDescriptorModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a descriptor model for interest point matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="detectorType">The type of the detector. Default: "lepetit"</param>
		/// <param name="detectorParamName">The detector's parameter names. Default: []</param>
		/// <param name="detectorParamValue">Values of the detector's parameters. Default: []</param>
		/// <param name="descriptorParamName">The descriptor's parameter names. Default: []</param>
		/// <param name="descriptorParamValue">Values of the descriptor's parameters. Default: []</param>
		/// <param name="seed">The seed for the random number generator. Default: 42</param>
		/// <returns>The handle to the descriptor model.</returns>
		// Token: 0x06000777 RID: 1911 RVA: 0x0002EE28 File Offset: 0x0002D028
		public HDescriptorModel CreateUncalibDescriptorModel(string detectorType, HTuple detectorParamName, HTuple detectorParamValue, HTuple descriptorParamName, HTuple descriptorParamValue, int seed)
		{
			IntPtr proc = HalconAPI.PreCall(953);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, detectorType);
			HalconAPI.Store(proc, 1, detectorParamName);
			HalconAPI.Store(proc, 2, detectorParamValue);
			HalconAPI.Store(proc, 3, descriptorParamName);
			HalconAPI.Store(proc, 4, descriptorParamValue);
			HalconAPI.StoreI(proc, 5, seed);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(detectorParamName);
			HalconAPI.UnpinTuple(detectorParamValue);
			HalconAPI.UnpinTuple(descriptorParamName);
			HalconAPI.UnpinTuple(descriptorParamValue);
			HDescriptorModel result;
			num = HDescriptorModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the parameters of a deformable model.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="optimization">Kind of optimization. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameter. Default: []</param>
		/// <param name="parameters">Parameters to be determined automatically. Default: "all"</param>
		/// <param name="parameterValue">Value of the automatically determined parameter.</param>
		/// <returns>Name of the automatically determined parameter.</returns>
		// Token: 0x06000778 RID: 1912 RVA: 0x0002EEC0 File Offset: 0x0002D0C0
		public HTuple DetermineDeformableModelParams(HTuple numLevels, double angleStart, double angleExtent, HTuple scaleMin, HTuple scaleMax, string optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue, HTuple parameters, out HTuple parameterValue)
		{
			IntPtr proc = HalconAPI.PreCall(962);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, scaleMin);
			HalconAPI.Store(proc, 4, scaleMax);
			HalconAPI.StoreS(proc, 5, optimization);
			HalconAPI.StoreS(proc, 6, metric);
			HalconAPI.Store(proc, 7, contrast);
			HalconAPI.Store(proc, 8, minContrast);
			HalconAPI.Store(proc, 9, genParamName);
			HalconAPI.Store(proc, 10, genParamValue);
			HalconAPI.Store(proc, 11, parameters);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(scaleMin);
			HalconAPI.UnpinTuple(scaleMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.UnpinTuple(parameters);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out parameterValue);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the parameters of a deformable model.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleMin">Minimum scale of the model. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the model. Default: 1.1</param>
		/// <param name="optimization">Kind of optimization. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Threshold or hysteresis thresholds for the contrast of the object in the template image and optionally minimum size of the object parts. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameter. Default: []</param>
		/// <param name="parameters">Parameters to be determined automatically. Default: "all"</param>
		/// <param name="parameterValue">Value of the automatically determined parameter.</param>
		/// <returns>Name of the automatically determined parameter.</returns>
		// Token: 0x06000779 RID: 1913 RVA: 0x0002EFC0 File Offset: 0x0002D1C0
		public HTuple DetermineDeformableModelParams(int numLevels, double angleStart, double angleExtent, double scaleMin, double scaleMax, string optimization, string metric, int contrast, int minContrast, HTuple genParamName, HTuple genParamValue, string parameters, out HTuple parameterValue)
		{
			IntPtr proc = HalconAPI.PreCall(962);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleMin);
			HalconAPI.StoreD(proc, 4, scaleMax);
			HalconAPI.StoreS(proc, 5, optimization);
			HalconAPI.StoreS(proc, 6, metric);
			HalconAPI.StoreI(proc, 7, contrast);
			HalconAPI.StoreI(proc, 8, minContrast);
			HalconAPI.Store(proc, 9, genParamName);
			HalconAPI.Store(proc, 10, genParamValue);
			HalconAPI.StoreS(proc, 11, parameters);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out parameterValue);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find the best matches of a local deformable model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="vectorField">Vector field of the rectification transformation.</param>
		/// <param name="deformedContours">Contours of the found instances of the model.</param>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minumum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching. Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="resultType">Switch for requested iconic result. Default: []</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="score">Scores of the found instances of the model.</param>
		/// <param name="row">Row coordinates of the found instances of the model.</param>
		/// <param name="column">Column coordinates of the found instances of the model.</param>
		/// <returns>Rectified image of the found model.</returns>
		// Token: 0x0600077A RID: 1914 RVA: 0x0002F098 File Offset: 0x0002D298
		public HImage FindLocalDeformableModel(out HImage vectorField, out HXLDCont deformedContours, HDeformableModel modelID, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, int numLevels, double greediness, HTuple resultType, HTuple genParamName, HTuple genParamValue, out HTuple score, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(969);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreI(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, resultType);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(resultType);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out vectorField);
			num = HXLDCont.LoadNew(proc, 3, num, out deformedContours);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a calibrated deformable model in an image and return their 3D pose.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="covPose">6 standard deviations or 36 covariances of the pose parameters.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Pose of the object.</returns>
		// Token: 0x0600077B RID: 1915 RVA: 0x0002F1E8 File Offset: 0x0002D3E8
		public HPose[] FindPlanarCalibDeformableModel(HDeformableModel modelID, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, HTuple numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple covPose, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(970);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a calibrated deformable model in an image and return their 3D pose.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="covPose">6 standard deviations or 36 covariances of the pose parameters.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Pose of the object.</returns>
		// Token: 0x0600077C RID: 1916 RVA: 0x0002F2F8 File Offset: 0x0002D4F8
		public HPose FindPlanarCalibDeformableModel(HDeformableModel modelID, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, int numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple covPose, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(970);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreI(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a planar projective invariant deformable model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Homographies between model and found instances.</returns>
		// Token: 0x0600077D RID: 1917 RVA: 0x0002F3FC File Offset: 0x0002D5FC
		public HHomMat2D[] FindPlanarUncalibDeformableModel(HDeformableModel modelID, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, HTuple numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(971);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			HHomMat2D[] result = HHomMat2D.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a planar projective invariant deformable model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Homographies between model and found instances.</returns>
		// Token: 0x0600077E RID: 1918 RVA: 0x0002F4F8 File Offset: 0x0002D6F8
		public HHomMat2D FindPlanarUncalibDeformableModel(HDeformableModel modelID, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, int numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(971);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreI(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>
		///   Set the metric of a local deformable model that was created from XLD contours.
		///   Instance represents: Input image used for the determination of the polarity.
		/// </summary>
		/// <param name="vectorField">Vector field of the local deformation.</param>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x0600077F RID: 1919 RVA: 0x0002F5E8 File Offset: 0x0002D7E8
		public void SetLocalDeformableModelMetric(HImage vectorField, HDeformableModel modelID, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(972);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, vectorField);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreS(proc, 1, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(vectorField);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Set the metric of a planar calibrated deformable model that was created from XLD contours.
		///   Instance represents: Input image used for the determination of the polarity.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="pose">Pose of the model in the image.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x06000780 RID: 1920 RVA: 0x0002F640 File Offset: 0x0002D840
		public void SetPlanarCalibDeformableModelMetric(HDeformableModel modelID, HPose pose, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(973);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, pose);
			HalconAPI.StoreS(proc, 2, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Set the metric of a planar uncalibrated deformable model that was created from XLD contours.
		///   Instance represents: Input image used for the determination of the polarity.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x06000781 RID: 1921 RVA: 0x0002F6A4 File Offset: 0x0002D8A4
		public void SetPlanarUncalibDeformableModelMetric(HDeformableModel modelID, HHomMat2D homMat2D, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(974);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreS(proc, 2, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Creates a deformable model for local, deformable matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06000782 RID: 1922 RVA: 0x0002F708 File Offset: 0x0002D908
		public HDeformableModel CreateLocalDeformableModel(HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(978);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Creates a deformable model for local, deformable matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06000783 RID: 1923 RVA: 0x0002F83C File Offset: 0x0002DA3C
		public HDeformableModel CreateLocalDeformableModel(int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(978);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create a deformable model for calibrated perspective matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object in the reference image.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06000784 RID: 1924 RVA: 0x0002F948 File Offset: 0x0002DB48
		public HDeformableModel CreatePlanarCalibDeformableModel(HCamPar camParam, HPose referencePose, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(979);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.Store(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.Store(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.Store(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.Store(proc, 11, scaleCStep);
			HalconAPI.Store(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.Store(proc, 14, contrast);
			HalconAPI.Store(proc, 15, minContrast);
			HalconAPI.Store(proc, 16, genParamName);
			HalconAPI.Store(proc, 17, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create a deformable model for calibrated perspective matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object in the reference image.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06000785 RID: 1925 RVA: 0x0002FAB4 File Offset: 0x0002DCB4
		public HDeformableModel CreatePlanarCalibDeformableModel(HCamPar camParam, HPose referencePose, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(979);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.StoreI(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.StoreD(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.StoreD(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.StoreD(proc, 11, scaleCStep);
			HalconAPI.StoreS(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.Store(proc, 14, contrast);
			HalconAPI.StoreI(proc, 15, minContrast);
			HalconAPI.Store(proc, 16, genParamName);
			HalconAPI.Store(proc, 17, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Creates a deformable model for uncalibrated, perspective matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06000786 RID: 1926 RVA: 0x0002FBF8 File Offset: 0x0002DDF8
		public HDeformableModel CreatePlanarUncalibDeformableModel(HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(980);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Creates a deformable model for uncalibrated, perspective matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06000787 RID: 1927 RVA: 0x0002FD2C File Offset: 0x0002DF2C
		public HDeformableModel CreatePlanarUncalibDeformableModel(int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(980);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find the best matches of an NCC model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.8</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy. Default: "true"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000788 RID: 1928 RVA: 0x0002FE38 File Offset: 0x0002E038
		public void FindNccModel(HNCCModel modelID, double angleStart, double angleExtent, double minScore, int numMatches, double maxOverlap, string subPixel, HTuple numLevels, out HTuple row, out HTuple column, out HTuple angle, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(991);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, subPixel);
			HalconAPI.Store(proc, 7, numLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Find the best matches of an NCC model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.8</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy. Default: "true"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="row">Row coordinate of the found instances of the model.</param>
		/// <param name="column">Column coordinate of the found instances of the model.</param>
		/// <param name="angle">Rotation angle of the found instances of the model.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		// Token: 0x06000789 RID: 1929 RVA: 0x0002FF10 File Offset: 0x0002E110
		public void FindNccModel(HNCCModel modelID, double angleStart, double angleExtent, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, out HTuple row, out HTuple column, out HTuple angle, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(991);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, subPixel);
			HalconAPI.StoreI(proc, 7, numLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelID);
		}

		/// <summary>Set selected parameters of the NCC model.</summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x0600078A RID: 1930 RVA: 0x0002FFE0 File Offset: 0x0002E1E0
		public static void SetNccModelParam(HNCCModel modelID, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(992);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Prepare an NCC model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600078B RID: 1931 RVA: 0x00030030 File Offset: 0x0002E230
		public HNCCModel CreateNccModel(HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(993);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, metric);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HNCCModel result;
			num = HNCCModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an NCC model for matching.
		///   Instance represents: Input image whose domain will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x0600078C RID: 1932 RVA: 0x000300B0 File Offset: 0x0002E2B0
		public HNCCModel CreateNccModel(int numLevels, double angleStart, double angleExtent, double angleStep, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(993);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, metric);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HNCCModel result;
			num = HNCCModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find the best matches of a component model in an image.
		///   Instance represents: Input image in which the component model should be found.
		/// </summary>
		/// <param name="componentModelID">Handle of the component model.</param>
		/// <param name="rootComponent">Index of the root component.</param>
		/// <param name="angleStartRoot">Smallest rotation of the root component Default: -0.39</param>
		/// <param name="angleExtentRoot">Extent of the rotation of the root component. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the component model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the component model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the component models to be found. Default: 0.5</param>
		/// <param name="ifRootNotFound">Behavior if the root component is missing. Default: "stop_search"</param>
		/// <param name="ifComponentNotFound">Behavior if a component is missing. Default: "prune_branch"</param>
		/// <param name="posePrediction">Pose prediction of components that are not found. Default: "none"</param>
		/// <param name="minScoreComp">Minimum score of the instances of the components to be found. Default: 0.5</param>
		/// <param name="subPixelComp">Subpixel accuracy of the component poses if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevelsComp">Number of pyramid levels for the components used in the matching (and lowest pyramid level to use if $|NumLevelsComp| = 2n$). Default: 0</param>
		/// <param name="greedinessComp">"Greediness" of the search heuristic for the components (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="modelEnd">End index of each found instance of the component model in the tuples describing the component matches.</param>
		/// <param name="score">Score of the found instances of the component model.</param>
		/// <param name="rowComp">Row coordinate of the found component matches.</param>
		/// <param name="columnComp">Column coordinate of the found component matches.</param>
		/// <param name="angleComp">Rotation angle of the found component matches.</param>
		/// <param name="scoreComp">Score of the found component matches.</param>
		/// <param name="modelComp">Index of the found components.</param>
		/// <returns>Start index of each found instance of the component model in the tuples describing the component matches.</returns>
		// Token: 0x0600078D RID: 1933 RVA: 0x00030124 File Offset: 0x0002E324
		public HTuple FindComponentModel(HComponentModel componentModelID, HTuple rootComponent, HTuple angleStartRoot, HTuple angleExtentRoot, double minScore, int numMatches, double maxOverlap, string ifRootNotFound, string ifComponentNotFound, string posePrediction, HTuple minScoreComp, HTuple subPixelComp, HTuple numLevelsComp, HTuple greedinessComp, out HTuple modelEnd, out HTuple score, out HTuple rowComp, out HTuple columnComp, out HTuple angleComp, out HTuple scoreComp, out HTuple modelComp)
		{
			IntPtr proc = HalconAPI.PreCall(995);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, componentModelID);
			HalconAPI.Store(proc, 1, rootComponent);
			HalconAPI.Store(proc, 2, angleStartRoot);
			HalconAPI.Store(proc, 3, angleExtentRoot);
			HalconAPI.StoreD(proc, 4, minScore);
			HalconAPI.StoreI(proc, 5, numMatches);
			HalconAPI.StoreD(proc, 6, maxOverlap);
			HalconAPI.StoreS(proc, 7, ifRootNotFound);
			HalconAPI.StoreS(proc, 8, ifComponentNotFound);
			HalconAPI.StoreS(proc, 9, posePrediction);
			HalconAPI.Store(proc, 10, minScoreComp);
			HalconAPI.Store(proc, 11, subPixelComp);
			HalconAPI.Store(proc, 12, numLevelsComp);
			HalconAPI.Store(proc, 13, greedinessComp);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rootComponent);
			HalconAPI.UnpinTuple(angleStartRoot);
			HalconAPI.UnpinTuple(angleExtentRoot);
			HalconAPI.UnpinTuple(minScoreComp);
			HalconAPI.UnpinTuple(subPixelComp);
			HalconAPI.UnpinTuple(numLevelsComp);
			HalconAPI.UnpinTuple(greedinessComp);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out modelEnd);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rowComp);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out columnComp);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out angleComp);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out scoreComp);
			num = HTuple.LoadNew(proc, 7, HTupleType.INTEGER, num, out modelComp);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(componentModelID);
			return result;
		}

		/// <summary>
		///   Find the best matches of a component model in an image.
		///   Instance represents: Input image in which the component model should be found.
		/// </summary>
		/// <param name="componentModelID">Handle of the component model.</param>
		/// <param name="rootComponent">Index of the root component.</param>
		/// <param name="angleStartRoot">Smallest rotation of the root component Default: -0.39</param>
		/// <param name="angleExtentRoot">Extent of the rotation of the root component. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the component model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the component model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the component models to be found. Default: 0.5</param>
		/// <param name="ifRootNotFound">Behavior if the root component is missing. Default: "stop_search"</param>
		/// <param name="ifComponentNotFound">Behavior if a component is missing. Default: "prune_branch"</param>
		/// <param name="posePrediction">Pose prediction of components that are not found. Default: "none"</param>
		/// <param name="minScoreComp">Minimum score of the instances of the components to be found. Default: 0.5</param>
		/// <param name="subPixelComp">Subpixel accuracy of the component poses if not equal to 'none'. Default: "least_squares"</param>
		/// <param name="numLevelsComp">Number of pyramid levels for the components used in the matching (and lowest pyramid level to use if $|NumLevelsComp| = 2n$). Default: 0</param>
		/// <param name="greedinessComp">"Greediness" of the search heuristic for the components (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="modelEnd">End index of each found instance of the component model in the tuples describing the component matches.</param>
		/// <param name="score">Score of the found instances of the component model.</param>
		/// <param name="rowComp">Row coordinate of the found component matches.</param>
		/// <param name="columnComp">Column coordinate of the found component matches.</param>
		/// <param name="angleComp">Rotation angle of the found component matches.</param>
		/// <param name="scoreComp">Score of the found component matches.</param>
		/// <param name="modelComp">Index of the found components.</param>
		/// <returns>Start index of each found instance of the component model in the tuples describing the component matches.</returns>
		// Token: 0x0600078E RID: 1934 RVA: 0x000302B0 File Offset: 0x0002E4B0
		public int FindComponentModel(HComponentModel componentModelID, int rootComponent, double angleStartRoot, double angleExtentRoot, double minScore, int numMatches, double maxOverlap, string ifRootNotFound, string ifComponentNotFound, string posePrediction, double minScoreComp, string subPixelComp, int numLevelsComp, double greedinessComp, out int modelEnd, out double score, out double rowComp, out double columnComp, out double angleComp, out double scoreComp, out int modelComp)
		{
			IntPtr proc = HalconAPI.PreCall(995);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, componentModelID);
			HalconAPI.StoreI(proc, 1, rootComponent);
			HalconAPI.StoreD(proc, 2, angleStartRoot);
			HalconAPI.StoreD(proc, 3, angleExtentRoot);
			HalconAPI.StoreD(proc, 4, minScore);
			HalconAPI.StoreI(proc, 5, numMatches);
			HalconAPI.StoreD(proc, 6, maxOverlap);
			HalconAPI.StoreS(proc, 7, ifRootNotFound);
			HalconAPI.StoreS(proc, 8, ifComponentNotFound);
			HalconAPI.StoreS(proc, 9, posePrediction);
			HalconAPI.StoreD(proc, 10, minScoreComp);
			HalconAPI.StoreS(proc, 11, subPixelComp);
			HalconAPI.StoreI(proc, 12, numLevelsComp);
			HalconAPI.StoreD(proc, 13, greedinessComp);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out modelEnd);
			num = HalconAPI.LoadD(proc, 2, num, out score);
			num = HalconAPI.LoadD(proc, 3, num, out rowComp);
			num = HalconAPI.LoadD(proc, 4, num, out columnComp);
			num = HalconAPI.LoadD(proc, 5, num, out angleComp);
			num = HalconAPI.LoadD(proc, 6, num, out scoreComp);
			num = HalconAPI.LoadI(proc, 7, num, out modelComp);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(componentModelID);
			return result;
		}

		/// <summary>
		///   Prepare a component model for matching based on explicitly specified components and relations.
		///   Instance represents: Input image from which the shape models of the model components should be created.
		/// </summary>
		/// <param name="componentRegions">Input regions from which the shape models of the model components should be created.</param>
		/// <param name="variationRow">Variation of the model components in row direction.</param>
		/// <param name="variationColumn">Variation of the model components in column direction.</param>
		/// <param name="variationAngle">Angle variation of the model components.</param>
		/// <param name="angleStart">Smallest rotation of the component model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation of the component model. Default: 0.79</param>
		/// <param name="contrastLowComp">Lower hysteresis threshold for the contrast of the components in the model image. Default: "auto"</param>
		/// <param name="contrastHighComp">Upper hysteresis threshold for the contrast of the components in the model image. Default: "auto"</param>
		/// <param name="minSizeComp">Minimum size of the contour regions in the model. Default: "auto"</param>
		/// <param name="minContrastComp">Minimum contrast of the components in the search images. Default: "auto"</param>
		/// <param name="minScoreComp">Minimum score of the instances of the components to be found. Default: 0.5</param>
		/// <param name="numLevelsComp">Maximum number of pyramid levels for the components. Default: "auto"</param>
		/// <param name="angleStepComp">Step length of the angles (resolution) for the components. Default: "auto"</param>
		/// <param name="optimizationComp">Kind of optimization for the components. Default: "auto"</param>
		/// <param name="metricComp">Match metric used for the components. Default: "use_polarity"</param>
		/// <param name="pregenerationComp">Complete pregeneration of the shape models for the components if equal to 'true'. Default: "false"</param>
		/// <param name="rootRanking">Ranking of the model components expressing the suitability to act as the root component.</param>
		/// <returns>Handle of the component model.</returns>
		// Token: 0x0600078F RID: 1935 RVA: 0x00030404 File Offset: 0x0002E604
		public HComponentModel CreateComponentModel(HRegion componentRegions, HTuple variationRow, HTuple variationColumn, HTuple variationAngle, double angleStart, double angleExtent, HTuple contrastLowComp, HTuple contrastHighComp, HTuple minSizeComp, HTuple minContrastComp, HTuple minScoreComp, HTuple numLevelsComp, HTuple angleStepComp, string optimizationComp, HTuple metricComp, HTuple pregenerationComp, out HTuple rootRanking)
		{
			IntPtr proc = HalconAPI.PreCall(1004);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, componentRegions);
			HalconAPI.Store(proc, 0, variationRow);
			HalconAPI.Store(proc, 1, variationColumn);
			HalconAPI.Store(proc, 2, variationAngle);
			HalconAPI.StoreD(proc, 3, angleStart);
			HalconAPI.StoreD(proc, 4, angleExtent);
			HalconAPI.Store(proc, 5, contrastLowComp);
			HalconAPI.Store(proc, 6, contrastHighComp);
			HalconAPI.Store(proc, 7, minSizeComp);
			HalconAPI.Store(proc, 8, minContrastComp);
			HalconAPI.Store(proc, 9, minScoreComp);
			HalconAPI.Store(proc, 10, numLevelsComp);
			HalconAPI.Store(proc, 11, angleStepComp);
			HalconAPI.StoreS(proc, 12, optimizationComp);
			HalconAPI.Store(proc, 13, metricComp);
			HalconAPI.Store(proc, 14, pregenerationComp);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(variationRow);
			HalconAPI.UnpinTuple(variationColumn);
			HalconAPI.UnpinTuple(variationAngle);
			HalconAPI.UnpinTuple(contrastLowComp);
			HalconAPI.UnpinTuple(contrastHighComp);
			HalconAPI.UnpinTuple(minSizeComp);
			HalconAPI.UnpinTuple(minContrastComp);
			HalconAPI.UnpinTuple(minScoreComp);
			HalconAPI.UnpinTuple(numLevelsComp);
			HalconAPI.UnpinTuple(angleStepComp);
			HalconAPI.UnpinTuple(metricComp);
			HalconAPI.UnpinTuple(pregenerationComp);
			HComponentModel result;
			num = HComponentModel.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out rootRanking);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(componentRegions);
			return result;
		}

		/// <summary>
		///   Prepare a component model for matching based on explicitly specified components and relations.
		///   Instance represents: Input image from which the shape models of the model components should be created.
		/// </summary>
		/// <param name="componentRegions">Input regions from which the shape models of the model components should be created.</param>
		/// <param name="variationRow">Variation of the model components in row direction.</param>
		/// <param name="variationColumn">Variation of the model components in column direction.</param>
		/// <param name="variationAngle">Angle variation of the model components.</param>
		/// <param name="angleStart">Smallest rotation of the component model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation of the component model. Default: 0.79</param>
		/// <param name="contrastLowComp">Lower hysteresis threshold for the contrast of the components in the model image. Default: "auto"</param>
		/// <param name="contrastHighComp">Upper hysteresis threshold for the contrast of the components in the model image. Default: "auto"</param>
		/// <param name="minSizeComp">Minimum size of the contour regions in the model. Default: "auto"</param>
		/// <param name="minContrastComp">Minimum contrast of the components in the search images. Default: "auto"</param>
		/// <param name="minScoreComp">Minimum score of the instances of the components to be found. Default: 0.5</param>
		/// <param name="numLevelsComp">Maximum number of pyramid levels for the components. Default: "auto"</param>
		/// <param name="angleStepComp">Step length of the angles (resolution) for the components. Default: "auto"</param>
		/// <param name="optimizationComp">Kind of optimization for the components. Default: "auto"</param>
		/// <param name="metricComp">Match metric used for the components. Default: "use_polarity"</param>
		/// <param name="pregenerationComp">Complete pregeneration of the shape models for the components if equal to 'true'. Default: "false"</param>
		/// <param name="rootRanking">Ranking of the model components expressing the suitability to act as the root component.</param>
		/// <returns>Handle of the component model.</returns>
		// Token: 0x06000790 RID: 1936 RVA: 0x0003054C File Offset: 0x0002E74C
		public HComponentModel CreateComponentModel(HRegion componentRegions, int variationRow, int variationColumn, double variationAngle, double angleStart, double angleExtent, int contrastLowComp, int contrastHighComp, int minSizeComp, int minContrastComp, double minScoreComp, int numLevelsComp, double angleStepComp, string optimizationComp, string metricComp, string pregenerationComp, out int rootRanking)
		{
			IntPtr proc = HalconAPI.PreCall(1004);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, componentRegions);
			HalconAPI.StoreI(proc, 0, variationRow);
			HalconAPI.StoreI(proc, 1, variationColumn);
			HalconAPI.StoreD(proc, 2, variationAngle);
			HalconAPI.StoreD(proc, 3, angleStart);
			HalconAPI.StoreD(proc, 4, angleExtent);
			HalconAPI.StoreI(proc, 5, contrastLowComp);
			HalconAPI.StoreI(proc, 6, contrastHighComp);
			HalconAPI.StoreI(proc, 7, minSizeComp);
			HalconAPI.StoreI(proc, 8, minContrastComp);
			HalconAPI.StoreD(proc, 9, minScoreComp);
			HalconAPI.StoreI(proc, 10, numLevelsComp);
			HalconAPI.StoreD(proc, 11, angleStepComp);
			HalconAPI.StoreS(proc, 12, optimizationComp);
			HalconAPI.StoreS(proc, 13, metricComp);
			HalconAPI.StoreS(proc, 14, pregenerationComp);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HComponentModel result;
			num = HComponentModel.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out rootRanking);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(componentRegions);
			return result;
		}

		/// <summary>
		///   Adopt new parameters that are used to create the model components into the training result.
		///   Instance represents: Training images that were used for training the model components.
		/// </summary>
		/// <param name="componentTrainingID">Handle of the training result.</param>
		/// <param name="ambiguityCriterion">Criterion for solving the ambiguities. Default: "rigidity"</param>
		/// <param name="maxContourOverlap">Maximum contour overlap of the found initial components. Default: 0.2</param>
		/// <param name="clusterThreshold">Threshold for clustering the initial components. Default: 0.5</param>
		/// <returns>Contour regions of rigid model components.</returns>
		// Token: 0x06000791 RID: 1937 RVA: 0x00030640 File Offset: 0x0002E840
		public HRegion ClusterModelComponents(HComponentTraining componentTrainingID, string ambiguityCriterion, double maxContourOverlap, double clusterThreshold)
		{
			IntPtr proc = HalconAPI.PreCall(1015);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, componentTrainingID);
			HalconAPI.StoreS(proc, 1, ambiguityCriterion);
			HalconAPI.StoreD(proc, 2, maxContourOverlap);
			HalconAPI.StoreD(proc, 3, clusterThreshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(componentTrainingID);
			return result;
		}

		/// <summary>
		///   Train components and relations for the component-based matching.
		///   Instance represents: Input image from which the shape models of the initial components should be created.
		/// </summary>
		/// <param name="initialComponents">Contour regions or enclosing regions of the initial components.</param>
		/// <param name="trainingImages">Training images that are used for training the model components.</param>
		/// <param name="contrastLow">Lower hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="contrastHigh">Upper hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="minSize">Minimum size of connected contour regions. Default: "auto"</param>
		/// <param name="minScore">Minimum score of the instances of the initial components to be found. Default: 0.5</param>
		/// <param name="searchRowTol">Search tolerance in row direction. Default: -1</param>
		/// <param name="searchColumnTol">Search tolerance in column direction. Default: -1</param>
		/// <param name="searchAngleTol">Angle search tolerance. Default: -1</param>
		/// <param name="trainingEmphasis">Decision whether the training emphasis should lie on a fast computation or on a high robustness. Default: "speed"</param>
		/// <param name="ambiguityCriterion">Criterion for solving ambiguous matches of the initial components in the training images. Default: "rigidity"</param>
		/// <param name="maxContourOverlap">Maximum contour overlap of the found initial components in a training image. Default: 0.2</param>
		/// <param name="clusterThreshold">Threshold for clustering the initial components. Default: 0.5</param>
		/// <param name="componentTrainingID">Handle of the training result.</param>
		/// <returns>Contour regions of rigid model components.</returns>
		// Token: 0x06000792 RID: 1938 RVA: 0x000306B0 File Offset: 0x0002E8B0
		public HRegion TrainModelComponents(HRegion initialComponents, HImage trainingImages, HTuple contrastLow, HTuple contrastHigh, HTuple minSize, HTuple minScore, HTuple searchRowTol, HTuple searchColumnTol, HTuple searchAngleTol, string trainingEmphasis, string ambiguityCriterion, double maxContourOverlap, double clusterThreshold, out HComponentTraining componentTrainingID)
		{
			IntPtr proc = HalconAPI.PreCall(1017);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, initialComponents);
			HalconAPI.Store(proc, 3, trainingImages);
			HalconAPI.Store(proc, 0, contrastLow);
			HalconAPI.Store(proc, 1, contrastHigh);
			HalconAPI.Store(proc, 2, minSize);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.Store(proc, 4, searchRowTol);
			HalconAPI.Store(proc, 5, searchColumnTol);
			HalconAPI.Store(proc, 6, searchAngleTol);
			HalconAPI.StoreS(proc, 7, trainingEmphasis);
			HalconAPI.StoreS(proc, 8, ambiguityCriterion);
			HalconAPI.StoreD(proc, 9, maxContourOverlap);
			HalconAPI.StoreD(proc, 10, clusterThreshold);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(contrastLow);
			HalconAPI.UnpinTuple(contrastHigh);
			HalconAPI.UnpinTuple(minSize);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(searchRowTol);
			HalconAPI.UnpinTuple(searchColumnTol);
			HalconAPI.UnpinTuple(searchAngleTol);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HComponentTraining.LoadNew(proc, 0, num, out componentTrainingID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(initialComponents);
			GC.KeepAlive(trainingImages);
			return result;
		}

		/// <summary>
		///   Train components and relations for the component-based matching.
		///   Instance represents: Input image from which the shape models of the initial components should be created.
		/// </summary>
		/// <param name="initialComponents">Contour regions or enclosing regions of the initial components.</param>
		/// <param name="trainingImages">Training images that are used for training the model components.</param>
		/// <param name="contrastLow">Lower hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="contrastHigh">Upper hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="minSize">Minimum size of connected contour regions. Default: "auto"</param>
		/// <param name="minScore">Minimum score of the instances of the initial components to be found. Default: 0.5</param>
		/// <param name="searchRowTol">Search tolerance in row direction. Default: -1</param>
		/// <param name="searchColumnTol">Search tolerance in column direction. Default: -1</param>
		/// <param name="searchAngleTol">Angle search tolerance. Default: -1</param>
		/// <param name="trainingEmphasis">Decision whether the training emphasis should lie on a fast computation or on a high robustness. Default: "speed"</param>
		/// <param name="ambiguityCriterion">Criterion for solving ambiguous matches of the initial components in the training images. Default: "rigidity"</param>
		/// <param name="maxContourOverlap">Maximum contour overlap of the found initial components in a training image. Default: 0.2</param>
		/// <param name="clusterThreshold">Threshold for clustering the initial components. Default: 0.5</param>
		/// <param name="componentTrainingID">Handle of the training result.</param>
		/// <returns>Contour regions of rigid model components.</returns>
		// Token: 0x06000793 RID: 1939 RVA: 0x000307BC File Offset: 0x0002E9BC
		public HRegion TrainModelComponents(HRegion initialComponents, HImage trainingImages, int contrastLow, int contrastHigh, int minSize, double minScore, int searchRowTol, int searchColumnTol, double searchAngleTol, string trainingEmphasis, string ambiguityCriterion, double maxContourOverlap, double clusterThreshold, out HComponentTraining componentTrainingID)
		{
			IntPtr proc = HalconAPI.PreCall(1017);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, initialComponents);
			HalconAPI.Store(proc, 3, trainingImages);
			HalconAPI.StoreI(proc, 0, contrastLow);
			HalconAPI.StoreI(proc, 1, contrastHigh);
			HalconAPI.StoreI(proc, 2, minSize);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, searchRowTol);
			HalconAPI.StoreI(proc, 5, searchColumnTol);
			HalconAPI.StoreD(proc, 6, searchAngleTol);
			HalconAPI.StoreS(proc, 7, trainingEmphasis);
			HalconAPI.StoreS(proc, 8, ambiguityCriterion);
			HalconAPI.StoreD(proc, 9, maxContourOverlap);
			HalconAPI.StoreD(proc, 10, clusterThreshold);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HComponentTraining.LoadNew(proc, 0, num, out componentTrainingID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(initialComponents);
			GC.KeepAlive(trainingImages);
			return result;
		}

		/// <summary>
		///   Extract the initial components of a component model.
		///   Instance represents: Input image from which the initial components should be extracted.
		/// </summary>
		/// <param name="contrastLow">Lower hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="contrastHigh">Upper hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="minSize">Minimum size of the initial components. Default: "auto"</param>
		/// <param name="mode">Type of automatic segmentation. Default: "connection"</param>
		/// <param name="genericName">Names of optional control parameters. Default: []</param>
		/// <param name="genericValue">Values of optional control parameters. Default: []</param>
		/// <returns>Contour regions of initial components.</returns>
		// Token: 0x06000794 RID: 1940 RVA: 0x00030898 File Offset: 0x0002EA98
		public HRegion GenInitialComponents(HTuple contrastLow, HTuple contrastHigh, HTuple minSize, string mode, HTuple genericName, HTuple genericValue)
		{
			IntPtr proc = HalconAPI.PreCall(1018);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, contrastLow);
			HalconAPI.Store(proc, 1, contrastHigh);
			HalconAPI.Store(proc, 2, minSize);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.Store(proc, 4, genericName);
			HalconAPI.Store(proc, 5, genericValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(contrastLow);
			HalconAPI.UnpinTuple(contrastHigh);
			HalconAPI.UnpinTuple(minSize);
			HalconAPI.UnpinTuple(genericName);
			HalconAPI.UnpinTuple(genericValue);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract the initial components of a component model.
		///   Instance represents: Input image from which the initial components should be extracted.
		/// </summary>
		/// <param name="contrastLow">Lower hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="contrastHigh">Upper hysteresis threshold for the contrast of the initial components in the image. Default: "auto"</param>
		/// <param name="minSize">Minimum size of the initial components. Default: "auto"</param>
		/// <param name="mode">Type of automatic segmentation. Default: "connection"</param>
		/// <param name="genericName">Names of optional control parameters. Default: []</param>
		/// <param name="genericValue">Values of optional control parameters. Default: []</param>
		/// <returns>Contour regions of initial components.</returns>
		// Token: 0x06000795 RID: 1941 RVA: 0x00030934 File Offset: 0x0002EB34
		public HRegion GenInitialComponents(int contrastLow, int contrastHigh, int minSize, string mode, string genericName, double genericValue)
		{
			IntPtr proc = HalconAPI.PreCall(1018);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, contrastLow);
			HalconAPI.StoreI(proc, 1, contrastHigh);
			HalconAPI.StoreI(proc, 2, minSize);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.StoreS(proc, 4, genericName);
			HalconAPI.StoreD(proc, 5, genericValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find the best matches of a 3D shape model in an image.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="shapeModel3DID">Handle of the 3D shape model.</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.7</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="genParamName">Names of (optional) parameters for controlling the behavior of the operator. Default: []</param>
		/// <param name="genParamValue">Values of the optional generic parameters. Default: []</param>
		/// <param name="covPose">6 standard deviations or 36 covariances of the pose parameters.</param>
		/// <param name="score">Score of the found instances of the 3D shape model.</param>
		/// <returns>3D pose of the 3D shape model.</returns>
		// Token: 0x06000796 RID: 1942 RVA: 0x000309B0 File Offset: 0x0002EBB0
		public HPose[] FindShapeModel3d(HShapeModel3D shapeModel3DID, double minScore, double greediness, HTuple numLevels, HTuple genParamName, HTuple genParamValue, out HTuple covPose, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(1058);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, shapeModel3DID);
			HalconAPI.StoreD(proc, 1, minScore);
			HalconAPI.StoreD(proc, 2, greediness);
			HalconAPI.Store(proc, 3, numLevels);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(shapeModel3DID);
			return result;
		}

		/// <summary>
		///   Convert one-channel images into a multi-channel image
		///   Instance represents: One-channel images to be combined into a one-channel image.
		/// </summary>
		/// <returns>Multi-channel image.</returns>
		// Token: 0x06000797 RID: 1943 RVA: 0x00030A74 File Offset: 0x0002EC74
		public HImage ChannelsToImage()
		{
			IntPtr proc = HalconAPI.PreCall(1119);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a multi-channel image into One-channel images
		///   Instance represents: Multi-channel image to be decomposed.
		/// </summary>
		/// <returns>Generated one-channel images.</returns>
		// Token: 0x06000798 RID: 1944 RVA: 0x00030ABC File Offset: 0x0002ECBC
		public HImage ImageToChannels()
		{
			IntPtr proc = HalconAPI.PreCall(1120);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert 7 images into a seven-channel image.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="image3">Input image 3.</param>
		/// <param name="image4">Input image 4.</param>
		/// <param name="image5">Input image 5.</param>
		/// <param name="image6">Input image 6.</param>
		/// <param name="image7">Input image 7.</param>
		/// <returns>Multi-channel image.</returns>
		// Token: 0x06000799 RID: 1945 RVA: 0x00030B04 File Offset: 0x0002ED04
		public HImage Compose7(HImage image2, HImage image3, HImage image4, HImage image5, HImage image6, HImage image7)
		{
			IntPtr proc = HalconAPI.PreCall(1121);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 3, image3);
			HalconAPI.Store(proc, 4, image4);
			HalconAPI.Store(proc, 5, image5);
			HalconAPI.Store(proc, 6, image6);
			HalconAPI.Store(proc, 7, image7);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			GC.KeepAlive(image3);
			GC.KeepAlive(image4);
			GC.KeepAlive(image5);
			GC.KeepAlive(image6);
			GC.KeepAlive(image7);
			return result;
		}

		/// <summary>
		///   Convert 6 images into a six-channel image.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="image3">Input image 3.</param>
		/// <param name="image4">Input image 4.</param>
		/// <param name="image5">Input image 5.</param>
		/// <param name="image6">Input image 6.</param>
		/// <returns>Multi-channel image.</returns>
		// Token: 0x0600079A RID: 1946 RVA: 0x00030BA8 File Offset: 0x0002EDA8
		public HImage Compose6(HImage image2, HImage image3, HImage image4, HImage image5, HImage image6)
		{
			IntPtr proc = HalconAPI.PreCall(1122);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 3, image3);
			HalconAPI.Store(proc, 4, image4);
			HalconAPI.Store(proc, 5, image5);
			HalconAPI.Store(proc, 6, image6);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			GC.KeepAlive(image3);
			GC.KeepAlive(image4);
			GC.KeepAlive(image5);
			GC.KeepAlive(image6);
			return result;
		}

		/// <summary>
		///   Convert 5 images into a five-channel image.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="image3">Input image 3.</param>
		/// <param name="image4">Input image 4.</param>
		/// <param name="image5">Input image 5.</param>
		/// <returns>Multi-channel image.</returns>
		// Token: 0x0600079B RID: 1947 RVA: 0x00030C3C File Offset: 0x0002EE3C
		public HImage Compose5(HImage image2, HImage image3, HImage image4, HImage image5)
		{
			IntPtr proc = HalconAPI.PreCall(1123);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 3, image3);
			HalconAPI.Store(proc, 4, image4);
			HalconAPI.Store(proc, 5, image5);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			GC.KeepAlive(image3);
			GC.KeepAlive(image4);
			GC.KeepAlive(image5);
			return result;
		}

		/// <summary>
		///   Convert 4 images into a four-channel image.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="image3">Input image 3.</param>
		/// <param name="image4">Input image 4.</param>
		/// <returns>Multi-channel image.</returns>
		// Token: 0x0600079C RID: 1948 RVA: 0x00030CC0 File Offset: 0x0002EEC0
		public HImage Compose4(HImage image2, HImage image3, HImage image4)
		{
			IntPtr proc = HalconAPI.PreCall(1124);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 3, image3);
			HalconAPI.Store(proc, 4, image4);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			GC.KeepAlive(image3);
			GC.KeepAlive(image4);
			return result;
		}

		/// <summary>
		///   Convert 3 images into a three-channel image.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="image3">Input image 3.</param>
		/// <returns>Multi-channel image.</returns>
		// Token: 0x0600079D RID: 1949 RVA: 0x00030D34 File Offset: 0x0002EF34
		public HImage Compose3(HImage image2, HImage image3)
		{
			IntPtr proc = HalconAPI.PreCall(1125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 3, image3);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			GC.KeepAlive(image3);
			return result;
		}

		/// <summary>
		///   Convert two images into a two-channel image.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <returns>Multi-channel image.</returns>
		// Token: 0x0600079E RID: 1950 RVA: 0x00030D98 File Offset: 0x0002EF98
		public HImage Compose2(HImage image2)
		{
			IntPtr proc = HalconAPI.PreCall(1126);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Convert a seven-channel image into seven images.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="image2">Output image 2.</param>
		/// <param name="image3">Output image 3.</param>
		/// <param name="image4">Output image 4.</param>
		/// <param name="image5">Output image 5.</param>
		/// <param name="image6">Output image 6.</param>
		/// <param name="image7">Output image 7.</param>
		/// <returns>Output image 1.</returns>
		// Token: 0x0600079F RID: 1951 RVA: 0x00030DF0 File Offset: 0x0002EFF0
		public HImage Decompose7(out HImage image2, out HImage image3, out HImage image4, out HImage image5, out HImage image6, out HImage image7)
		{
			IntPtr proc = HalconAPI.PreCall(1127);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out image2);
			num = HImage.LoadNew(proc, 3, num, out image3);
			num = HImage.LoadNew(proc, 4, num, out image4);
			num = HImage.LoadNew(proc, 5, num, out image5);
			num = HImage.LoadNew(proc, 6, num, out image6);
			num = HImage.LoadNew(proc, 7, num, out image7);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a six-channel image into six images.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="image2">Output image 2.</param>
		/// <param name="image3">Output image 3.</param>
		/// <param name="image4">Output image 4.</param>
		/// <param name="image5">Output image 5.</param>
		/// <param name="image6">Output image 6.</param>
		/// <returns>Output image 1.</returns>
		// Token: 0x060007A0 RID: 1952 RVA: 0x00030EA8 File Offset: 0x0002F0A8
		public HImage Decompose6(out HImage image2, out HImage image3, out HImage image4, out HImage image5, out HImage image6)
		{
			IntPtr proc = HalconAPI.PreCall(1128);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out image2);
			num = HImage.LoadNew(proc, 3, num, out image3);
			num = HImage.LoadNew(proc, 4, num, out image4);
			num = HImage.LoadNew(proc, 5, num, out image5);
			num = HImage.LoadNew(proc, 6, num, out image6);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a five-channel image into five images.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="image2">Output image 2.</param>
		/// <param name="image3">Output image 3.</param>
		/// <param name="image4">Output image 4.</param>
		/// <param name="image5">Output image 5.</param>
		/// <returns>Output image 1.</returns>
		// Token: 0x060007A1 RID: 1953 RVA: 0x00030F4C File Offset: 0x0002F14C
		public HImage Decompose5(out HImage image2, out HImage image3, out HImage image4, out HImage image5)
		{
			IntPtr proc = HalconAPI.PreCall(1129);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out image2);
			num = HImage.LoadNew(proc, 3, num, out image3);
			num = HImage.LoadNew(proc, 4, num, out image4);
			num = HImage.LoadNew(proc, 5, num, out image5);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a four-channel image into four images.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="image2">Output image 2.</param>
		/// <param name="image3">Output image 3.</param>
		/// <param name="image4">Output image 4.</param>
		/// <returns>Output image 1.</returns>
		// Token: 0x060007A2 RID: 1954 RVA: 0x00030FE0 File Offset: 0x0002F1E0
		public HImage Decompose4(out HImage image2, out HImage image3, out HImage image4)
		{
			IntPtr proc = HalconAPI.PreCall(1130);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out image2);
			num = HImage.LoadNew(proc, 3, num, out image3);
			num = HImage.LoadNew(proc, 4, num, out image4);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a three-channel image into three images.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="image2">Output image 2.</param>
		/// <param name="image3">Output image 3.</param>
		/// <returns>Output image 1.</returns>
		// Token: 0x060007A3 RID: 1955 RVA: 0x00031060 File Offset: 0x0002F260
		public HImage Decompose3(out HImage image2, out HImage image3)
		{
			IntPtr proc = HalconAPI.PreCall(1131);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out image2);
			num = HImage.LoadNew(proc, 3, num, out image3);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a two-channel image into two images.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="image2">Output image 2.</param>
		/// <returns>Output image 1.</returns>
		// Token: 0x060007A4 RID: 1956 RVA: 0x000310CC File Offset: 0x0002F2CC
		public HImage Decompose2(out HImage image2)
		{
			IntPtr proc = HalconAPI.PreCall(1132);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out image2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Count channels of image.
		///   Instance represents: One- or multi-channel image.
		/// </summary>
		/// <returns>Number of channels.</returns>
		// Token: 0x060007A5 RID: 1957 RVA: 0x00031128 File Offset: 0x0002F328
		public HTuple CountChannels()
		{
			IntPtr proc = HalconAPI.PreCall(1133);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Append additional matrices (channels) to the image.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="image">Image to be appended.</param>
		/// <returns>Image appended by Image.</returns>
		// Token: 0x060007A6 RID: 1958 RVA: 0x00031174 File Offset: 0x0002F374
		public HImage AppendChannel(HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(1134);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Access a channel of a multi-channel image.
		///   Instance represents: Multi-channel image.
		/// </summary>
		/// <param name="channel">Index of channel to be accessed. Default: 1</param>
		/// <returns>One channel of MultiChannelImage.</returns>
		// Token: 0x060007A7 RID: 1959 RVA: 0x000311CC File Offset: 0x0002F3CC
		public HImage AccessChannel(int channel)
		{
			IntPtr proc = HalconAPI.PreCall(1135);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, channel);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Tile multiple image objects into a large image with explicit positioning information.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="offsetRow">Row coordinate of the upper left corner of the input images in the output image. Default: 0</param>
		/// <param name="offsetCol">Column coordinate of the upper left corner of the input images in the output image. Default: 0</param>
		/// <param name="row1">Row coordinate of the upper left corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="col1">Column coordinate of the upper left corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="row2">Row coordinate of the lower right corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="col2">Column coordinate of the lower right corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="width">Width of the output image. Default: 512</param>
		/// <param name="height">Height of the output image. Default: 512</param>
		/// <returns>Tiled output image.</returns>
		// Token: 0x060007A8 RID: 1960 RVA: 0x0003121C File Offset: 0x0002F41C
		public HImage TileImagesOffset(HTuple offsetRow, HTuple offsetCol, HTuple row1, HTuple col1, HTuple row2, HTuple col2, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1136);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, offsetRow);
			HalconAPI.Store(proc, 1, offsetCol);
			HalconAPI.Store(proc, 2, row1);
			HalconAPI.Store(proc, 3, col1);
			HalconAPI.Store(proc, 4, row2);
			HalconAPI.Store(proc, 5, col2);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(offsetRow);
			HalconAPI.UnpinTuple(offsetCol);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(col1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(col2);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Tile multiple image objects into a large image with explicit positioning information.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="offsetRow">Row coordinate of the upper left corner of the input images in the output image. Default: 0</param>
		/// <param name="offsetCol">Column coordinate of the upper left corner of the input images in the output image. Default: 0</param>
		/// <param name="row1">Row coordinate of the upper left corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="col1">Column coordinate of the upper left corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="row2">Row coordinate of the lower right corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="col2">Column coordinate of the lower right corner of the copied part of the respective input image. Default: -1</param>
		/// <param name="width">Width of the output image. Default: 512</param>
		/// <param name="height">Height of the output image. Default: 512</param>
		/// <returns>Tiled output image.</returns>
		// Token: 0x060007A9 RID: 1961 RVA: 0x000312D0 File Offset: 0x0002F4D0
		public HImage TileImagesOffset(int offsetRow, int offsetCol, int row1, int col1, int row2, int col2, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1136);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, offsetRow);
			HalconAPI.StoreI(proc, 1, offsetCol);
			HalconAPI.StoreI(proc, 2, row1);
			HalconAPI.StoreI(proc, 3, col1);
			HalconAPI.StoreI(proc, 4, row2);
			HalconAPI.StoreI(proc, 5, col2);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Tile multiple image objects into a large image.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="numColumns">Number of columns to use for the output image. Default: 1</param>
		/// <param name="tileOrder">Order of the input images in the output image. Default: "vertical"</param>
		/// <returns>Tiled output image.</returns>
		// Token: 0x060007AA RID: 1962 RVA: 0x00031360 File Offset: 0x0002F560
		public HImage TileImages(int numColumns, string tileOrder)
		{
			IntPtr proc = HalconAPI.PreCall(1137);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numColumns);
			HalconAPI.StoreS(proc, 1, tileOrder);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Tile multiple images into a large image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="numColumns">Number of columns to use for the output image. Default: 1</param>
		/// <param name="tileOrder">Order of the input images in the output image. Default: "vertical"</param>
		/// <returns>Tiled output image.</returns>
		// Token: 0x060007AB RID: 1963 RVA: 0x000313B8 File Offset: 0x0002F5B8
		public HImage TileChannels(int numColumns, string tileOrder)
		{
			IntPtr proc = HalconAPI.PreCall(1138);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numColumns);
			HalconAPI.StoreS(proc, 1, tileOrder);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Cut out of defined gray values.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Image area.</returns>
		// Token: 0x060007AC RID: 1964 RVA: 0x00031410 File Offset: 0x0002F610
		public HImage CropDomain()
		{
			IntPtr proc = HalconAPI.PreCall(1139);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Cut out one or more rectangular image areas.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row1">Line index of upper left corner of image area. Default: 100</param>
		/// <param name="column1">Column index of upper left corner of image area. Default: 100</param>
		/// <param name="row2">Line index of lower right corner of image area. Default: 200</param>
		/// <param name="column2">Column index of lower right corner of image area. Default: 200</param>
		/// <returns>Image area.</returns>
		// Token: 0x060007AD RID: 1965 RVA: 0x00031458 File Offset: 0x0002F658
		public HImage CropRectangle1(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1140);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Cut out one or more rectangular image areas.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row1">Line index of upper left corner of image area. Default: 100</param>
		/// <param name="column1">Column index of upper left corner of image area. Default: 100</param>
		/// <param name="row2">Line index of lower right corner of image area. Default: 200</param>
		/// <param name="column2">Column index of lower right corner of image area. Default: 200</param>
		/// <returns>Image area.</returns>
		// Token: 0x060007AE RID: 1966 RVA: 0x000314DC File Offset: 0x0002F6DC
		public HImage CropRectangle1(int row1, int column1, int row2, int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1140);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row1);
			HalconAPI.StoreI(proc, 1, column1);
			HalconAPI.StoreI(proc, 2, row2);
			HalconAPI.StoreI(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Cut out one or more rectangular image areas.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Line index of upper left corner of image area. Default: 100</param>
		/// <param name="column">Column index of upper left corner of image area. Default: 100</param>
		/// <param name="width">Width of new image. Default: 128</param>
		/// <param name="height">Height of new image. Default: 128</param>
		/// <returns>Image area.</returns>
		// Token: 0x060007AF RID: 1967 RVA: 0x00031548 File Offset: 0x0002F748
		public HImage CropPart(HTuple row, HTuple column, HTuple width, HTuple height)
		{
			IntPtr proc = HalconAPI.PreCall(1141);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, width);
			HalconAPI.Store(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(width);
			HalconAPI.UnpinTuple(height);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Cut out one or more rectangular image areas.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Line index of upper left corner of image area. Default: 100</param>
		/// <param name="column">Column index of upper left corner of image area. Default: 100</param>
		/// <param name="width">Width of new image. Default: 128</param>
		/// <param name="height">Height of new image. Default: 128</param>
		/// <returns>Image area.</returns>
		// Token: 0x060007B0 RID: 1968 RVA: 0x000315CC File Offset: 0x0002F7CC
		public HImage CropPart(int row, int column, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1141);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Change image size.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="width">Width of new image. Default: 512</param>
		/// <param name="height">Height of new image. Default: 512</param>
		/// <returns>Image with new format.</returns>
		// Token: 0x060007B1 RID: 1969 RVA: 0x00031638 File Offset: 0x0002F838
		public HImage ChangeFormat(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1142);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Change definition domain of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="newDomain">New definition domain.</param>
		/// <returns>Image with new definition domain.</returns>
		// Token: 0x060007B2 RID: 1970 RVA: 0x00031690 File Offset: 0x0002F890
		public HImage ChangeDomain(HRegion newDomain)
		{
			IntPtr proc = HalconAPI.PreCall(1143);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, newDomain);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(newDomain);
			return result;
		}

		/// <summary>
		///   Reduce the domain of an image to a rectangle.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row1">Line index of upper left corner of image area. Default: 100</param>
		/// <param name="column1">Column index of upper left corner of image area. Default: 100</param>
		/// <param name="row2">Line index of lower right corner of image area. Default: 200</param>
		/// <param name="column2">Column index of lower right corner of image area. Default: 200</param>
		/// <returns>Image with reduced definition domain.</returns>
		// Token: 0x060007B3 RID: 1971 RVA: 0x000316E8 File Offset: 0x0002F8E8
		public HImage Rectangle1Domain(int row1, int column1, int row2, int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1145);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row1);
			HalconAPI.StoreI(proc, 1, column1);
			HalconAPI.StoreI(proc, 2, row2);
			HalconAPI.StoreI(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reduce the domain of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">New definition domain.</param>
		/// <returns>Image with reduced definition domain.</returns>
		// Token: 0x060007B4 RID: 1972 RVA: 0x00031754 File Offset: 0x0002F954
		public HImage ReduceDomain(HRegion region)
		{
			IntPtr proc = HalconAPI.PreCall(1146);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Expand the domain of an image to maximum.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Image with maximum definition domain.</returns>
		// Token: 0x060007B5 RID: 1973 RVA: 0x000317AC File Offset: 0x0002F9AC
		public HImage FullDomain()
		{
			IntPtr proc = HalconAPI.PreCall(1147);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the domain of an image.
		///   Instance represents: Input images.
		/// </summary>
		/// <returns>Definition domains of input images.</returns>
		// Token: 0x060007B6 RID: 1974 RVA: 0x000317F4 File Offset: 0x0002F9F4
		public HRegion GetDomain()
		{
			IntPtr proc = HalconAPI.PreCall(1148);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect lines in edge images with the help of the Hough transform using local gradient direction and return them in normal form.
		///   Instance represents: Image containing the edge direction. The edges are described by the image domain.
		/// </summary>
		/// <param name="lines">Regions of the input image that contributed to the local maxima.</param>
		/// <param name="directionUncertainty">Uncertainty of edge direction (in degrees). Default: 2</param>
		/// <param name="angleResolution">Resolution in the angle area (in 1/degrees). Default: 4</param>
		/// <param name="smoothing">Smoothing filter for hough image. Default: "mean"</param>
		/// <param name="filterSize">Required smoothing filter size. Default: 5</param>
		/// <param name="threshold">Threshold value in the Hough image. Default: 100</param>
		/// <param name="angleGap">Minimum distance of two maxima in the Hough image (direction: angle). Default: 5</param>
		/// <param name="distGap">Minimum distance of two maxima in the Hough image (direction: distance). Default: 5</param>
		/// <param name="genLines">Create line regions if 'true'. Default: "true"</param>
		/// <param name="angle">Angles (in radians) of the detected lines' normal vectors.</param>
		/// <param name="dist">Distance of the detected lines from the origin.</param>
		/// <returns>Hough transform.</returns>
		// Token: 0x060007B7 RID: 1975 RVA: 0x0003183C File Offset: 0x0002FA3C
		public HImage HoughLinesDir(out HRegion lines, int directionUncertainty, int angleResolution, string smoothing, int filterSize, int threshold, int angleGap, int distGap, string genLines, out HTuple angle, out HTuple dist)
		{
			IntPtr proc = HalconAPI.PreCall(1151);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, directionUncertainty);
			HalconAPI.StoreI(proc, 1, angleResolution);
			HalconAPI.StoreS(proc, 2, smoothing);
			HalconAPI.StoreI(proc, 3, filterSize);
			HalconAPI.StoreI(proc, 4, threshold);
			HalconAPI.StoreI(proc, 5, angleGap);
			HalconAPI.StoreI(proc, 6, distGap);
			HalconAPI.StoreS(proc, 7, genLines);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out lines);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out dist);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the Hough transform for lines using local gradient direction.
		///   Instance represents: Image containing the edge direction. The edges must be described by the image domain.
		/// </summary>
		/// <param name="directionUncertainty">Uncertainty of the edge direction (in degrees). Default: 2</param>
		/// <param name="angleResolution">Resolution in the angle area (in 1/degrees). Default: 4</param>
		/// <returns>Hough transform.</returns>
		// Token: 0x060007B8 RID: 1976 RVA: 0x00031904 File Offset: 0x0002FB04
		public HImage HoughLineTransDir(int directionUncertainty, int angleResolution)
		{
			IntPtr proc = HalconAPI.PreCall(1152);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, directionUncertainty);
			HalconAPI.StoreI(proc, 1, angleResolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment the rectification grid region in the image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="minContrast">Minimum contrast. Default: 8.0</param>
		/// <param name="radius">Radius of the circular structuring element. Default: 7.5</param>
		/// <returns>Output region containing the rectification grid.</returns>
		// Token: 0x060007B9 RID: 1977 RVA: 0x0003195C File Offset: 0x0002FB5C
		public HRegion FindRectificationGrid(HTuple minContrast, HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1156);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, minContrast);
			HalconAPI.Store(proc, 1, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(radius);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment the rectification grid region in the image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="minContrast">Minimum contrast. Default: 8.0</param>
		/// <param name="radius">Radius of the circular structuring element. Default: 7.5</param>
		/// <returns>Output region containing the rectification grid.</returns>
		// Token: 0x060007BA RID: 1978 RVA: 0x000319C0 File Offset: 0x0002FBC0
		public HRegion FindRectificationGrid(double minContrast, double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1156);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, minContrast);
			HalconAPI.StoreD(proc, 1, radius);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Establish connections between the grid points of the rectification grid.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="sigma">Size of the applied Gaussians. Default: 0.9</param>
		/// <param name="maxDist">Maximum distance of the connecting lines from the grid points. Default: 5.5</param>
		/// <returns>Output contours.</returns>
		// Token: 0x060007BB RID: 1979 RVA: 0x00031A18 File Offset: 0x0002FC18
		public HXLD ConnectGridPoints(HTuple row, HTuple column, HTuple sigma, HTuple maxDist)
		{
			IntPtr proc = HalconAPI.PreCall(1158);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, sigma);
			HalconAPI.Store(proc, 3, maxDist);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(sigma);
			HalconAPI.UnpinTuple(maxDist);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Establish connections between the grid points of the rectification grid.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="sigma">Size of the applied Gaussians. Default: 0.9</param>
		/// <param name="maxDist">Maximum distance of the connecting lines from the grid points. Default: 5.5</param>
		/// <returns>Output contours.</returns>
		// Token: 0x060007BC RID: 1980 RVA: 0x00031A9C File Offset: 0x0002FC9C
		public HXLD ConnectGridPoints(HTuple row, HTuple column, int sigma, double maxDist)
		{
			IntPtr proc = HalconAPI.PreCall(1158);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreI(proc, 2, sigma);
			HalconAPI.StoreD(proc, 3, maxDist);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="connectingLines">Input contours.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x060007BD RID: 1981 RVA: 0x00031B14 File Offset: 0x0002FD14
		public HImage GenGridRectificationMap(HXLD connectingLines, out HXLD meshes, int gridSpacing, HTuple rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, connectingLines);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.Store(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLD.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(connectingLines);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="connectingLines">Input contours.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x060007BE RID: 1982 RVA: 0x00031BC0 File Offset: 0x0002FDC0
		public HImage GenGridRectificationMap(HXLD connectingLines, out HXLD meshes, int gridSpacing, string rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, connectingLines);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.StoreS(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLD.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(connectingLines);
			return result;
		}

		/// <summary>
		///   Calculates image coordinates for a point in a 3D plot window.
		///   Instance represents: Displayed image.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row coordinate in the window.</param>
		/// <param name="column">Column coordinate in the window.</param>
		/// <param name="imageRow">Row coordinate in the image.</param>
		/// <param name="imageColumn">Column coordinate in the image.</param>
		/// <param name="height">Height value.</param>
		// Token: 0x060007BF RID: 1983 RVA: 0x00031C64 File Offset: 0x0002FE64
		public void UnprojectCoordinates(HWindow windowHandle, HTuple row, HTuple column, out int imageRow, out int imageColumn, out HTuple height)
		{
			IntPtr proc = HalconAPI.PreCall(1168);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			num = HalconAPI.LoadI(proc, 0, num, out imageRow);
			num = HalconAPI.LoadI(proc, 1, num, out imageColumn);
			num = HTuple.LoadNew(proc, 2, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Calculates image coordinates for a point in a 3D plot window.
		///   Instance represents: Displayed image.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="row">Row coordinate in the window.</param>
		/// <param name="column">Column coordinate in the window.</param>
		/// <param name="imageRow">Row coordinate in the image.</param>
		/// <param name="imageColumn">Column coordinate in the image.</param>
		/// <param name="height">Height value.</param>
		// Token: 0x060007C0 RID: 1984 RVA: 0x00031CFC File Offset: 0x0002FEFC
		public void UnprojectCoordinates(HWindow windowHandle, double row, double column, out int imageRow, out int imageColumn, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(1168);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out imageRow);
			num = HalconAPI.LoadI(proc, 1, num, out imageColumn);
			num = HalconAPI.LoadI(proc, 2, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Write the window content in an image object.
		///   Modified instance represents: Saved image.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x060007C1 RID: 1985 RVA: 0x00031D88 File Offset: 0x0002FF88
		public void DumpWindowImage(HWindow windowHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1184);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Displays gray value images.
		///   Instance represents: Gray value image to display.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x060007C2 RID: 1986 RVA: 0x00031DDC File Offset: 0x0002FFDC
		public void DispImage(HWindow windowHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1268);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Displays images with several channels.
		///   Instance represents: Multichannel images to be displayed.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="channel">Number of channel or the numbers of the RGB-channels Default: 1</param>
		// Token: 0x060007C3 RID: 1987 RVA: 0x00031E20 File Offset: 0x00030020
		public void DispChannel(HWindow windowHandle, HTuple channel)
		{
			IntPtr proc = HalconAPI.PreCall(1269);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.Store(proc, 1, channel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(channel);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Displays images with several channels.
		///   Instance represents: Multichannel images to be displayed.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="channel">Number of channel or the numbers of the RGB-channels Default: 1</param>
		// Token: 0x060007C4 RID: 1988 RVA: 0x00031E70 File Offset: 0x00030070
		public void DispChannel(HWindow windowHandle, int channel)
		{
			IntPtr proc = HalconAPI.PreCall(1269);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreI(proc, 1, channel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Displays a color (RGB) image
		///   Instance represents: Color image to display.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x060007C5 RID: 1989 RVA: 0x00031EBC File Offset: 0x000300BC
		public void DispColor(HWindow windowHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1270);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Visualize images using gnuplot.
		///   Instance represents: Image to be plotted.
		/// </summary>
		/// <param name="gnuplotFileID">Identifier for the gnuplot output stream.</param>
		/// <param name="samplesX">Number of samples in the x-direction. Default: 64</param>
		/// <param name="samplesY">Number of samples in the y-direction. Default: 64</param>
		/// <param name="viewRotX">Rotation of the plot about the x-axis. Default: 60</param>
		/// <param name="viewRotZ">Rotation of the plot about the z-axis. Default: 30</param>
		/// <param name="hidden3D">Plot the image with hidden surfaces removed. Default: "hidden3d"</param>
		// Token: 0x060007C6 RID: 1990 RVA: 0x00031F00 File Offset: 0x00030100
		public void GnuplotPlotImage(HGnuplot gnuplotFileID, int samplesX, int samplesY, HTuple viewRotX, HTuple viewRotZ, string hidden3D)
		{
			IntPtr proc = HalconAPI.PreCall(1297);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, gnuplotFileID);
			HalconAPI.StoreI(proc, 1, samplesX);
			HalconAPI.StoreI(proc, 2, samplesY);
			HalconAPI.Store(proc, 3, viewRotX);
			HalconAPI.Store(proc, 4, viewRotZ);
			HalconAPI.StoreS(proc, 5, hidden3D);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(viewRotX);
			HalconAPI.UnpinTuple(viewRotZ);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(gnuplotFileID);
		}

		/// <summary>
		///   Visualize images using gnuplot.
		///   Instance represents: Image to be plotted.
		/// </summary>
		/// <param name="gnuplotFileID">Identifier for the gnuplot output stream.</param>
		/// <param name="samplesX">Number of samples in the x-direction. Default: 64</param>
		/// <param name="samplesY">Number of samples in the y-direction. Default: 64</param>
		/// <param name="viewRotX">Rotation of the plot about the x-axis. Default: 60</param>
		/// <param name="viewRotZ">Rotation of the plot about the z-axis. Default: 30</param>
		/// <param name="hidden3D">Plot the image with hidden surfaces removed. Default: "hidden3d"</param>
		// Token: 0x060007C7 RID: 1991 RVA: 0x00031F7C File Offset: 0x0003017C
		public void GnuplotPlotImage(HGnuplot gnuplotFileID, int samplesX, int samplesY, double viewRotX, double viewRotZ, string hidden3D)
		{
			IntPtr proc = HalconAPI.PreCall(1297);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, gnuplotFileID);
			HalconAPI.StoreI(proc, 1, samplesX);
			HalconAPI.StoreI(proc, 2, samplesY);
			HalconAPI.StoreD(proc, 3, viewRotX);
			HalconAPI.StoreD(proc, 4, viewRotZ);
			HalconAPI.StoreS(proc, 5, hidden3D);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(gnuplotFileID);
		}

		/// <summary>
		///   Filter an image using a Laws texture filter.
		///   Instance represents: Images to which the texture transformation is to be applied.
		/// </summary>
		/// <param name="filterTypes">Desired filter. Default: "el"</param>
		/// <param name="shift">Shift to reduce the gray value dynamics. Default: 2</param>
		/// <param name="filterSize">Size of the filter kernel. Default: 5</param>
		/// <returns>Texture images.</returns>
		// Token: 0x060007C8 RID: 1992 RVA: 0x00031FEC File Offset: 0x000301EC
		public HImage TextureLaws(string filterTypes, int shift, int filterSize)
		{
			IntPtr proc = HalconAPI.PreCall(1402);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterTypes);
			HalconAPI.StoreI(proc, 1, shift);
			HalconAPI.StoreI(proc, 2, filterSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the standard deviation of gray values within rectangular windows.
		///   Instance represents: Image for which the standard deviation is to be calculated.
		/// </summary>
		/// <param name="width">Width of the mask in which the standard deviation is calculated. Default: 11</param>
		/// <param name="height">Height of the mask in which the standard deviation is calculated. Default: 11</param>
		/// <returns>Image containing the standard deviation.</returns>
		// Token: 0x060007C9 RID: 1993 RVA: 0x0003204C File Offset: 0x0003024C
		public HImage DeviationImage(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1403);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the entropy of gray values within a rectangular window.
		///   Instance represents: Image for which the entropy is to be calculated.
		/// </summary>
		/// <param name="width">Width of the mask in which the entropy is calculated. Default: 9</param>
		/// <param name="height">Height of the mask in which the entropy is calculated. Default: 9</param>
		/// <returns>Entropy image.</returns>
		// Token: 0x060007CA RID: 1994 RVA: 0x000320A4 File Offset: 0x000302A4
		public HImage EntropyImage(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1404);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform an isotropic diffusion of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Standard deviation of the Gauss distribution. Default: 1.0</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <returns>Output image.</returns>
		// Token: 0x060007CB RID: 1995 RVA: 0x000320FC File Offset: 0x000302FC
		public HImage IsotropicDiffusion(double sigma, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(1405);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform an anisotropic diffusion of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="mode">Diffusion coefficient as a function of the edge amplitude. Default: "weickert"</param>
		/// <param name="contrast">Contrast parameter. Default: 5.0</param>
		/// <param name="theta">Time step. Default: 1.0</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <returns>Output image.</returns>
		// Token: 0x060007CC RID: 1996 RVA: 0x00032154 File Offset: 0x00030354
		public HImage AnisotropicDiffusion(string mode, double contrast, double theta, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(1406);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreD(proc, 1, contrast);
			HalconAPI.StoreD(proc, 2, theta);
			HalconAPI.StoreI(proc, 3, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smooth an image using various filters.
		///   Instance represents: Image to be smoothed.
		/// </summary>
		/// <param name="filter">Filter. Default: "deriche2"</param>
		/// <param name="alpha">Filterparameter: small values cause strong smoothing (vice versa by using bei 'gauss'). Default: 0.5</param>
		/// <returns>Smoothed image.</returns>
		// Token: 0x060007CD RID: 1997 RVA: 0x000321C0 File Offset: 0x000303C0
		public HImage SmoothImage(string filter, double alpha)
		{
			IntPtr proc = HalconAPI.PreCall(1407);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Non-linear smoothing with the sigma filter.
		///   Instance represents: Image to be smoothed.
		/// </summary>
		/// <param name="maskHeight">Height of the mask (number of lines). Default: 5</param>
		/// <param name="maskWidth">Width of the mask (number of columns). Default: 5</param>
		/// <param name="sigma">Max. deviation to the average. Default: 3</param>
		/// <returns>Smoothed image.</returns>
		// Token: 0x060007CE RID: 1998 RVA: 0x00032218 File Offset: 0x00030418
		public HImage SigmaImage(int maskHeight, int maskWidth, int sigma)
		{
			IntPtr proc = HalconAPI.PreCall(1408);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskHeight);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.StoreI(proc, 2, sigma);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the average of maximum and minimum inside any mask.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="mask">Filter mask.</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007CF RID: 1999 RVA: 0x00032278 File Offset: 0x00030478
		public HImage MidrangeImage(HRegion mask, HTuple margin)
		{
			IntPtr proc = HalconAPI.PreCall(1409);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, mask);
			HalconAPI.Store(proc, 0, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(margin);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(mask);
			return result;
		}

		/// <summary>
		///   Calculate the average of maximum and minimum inside any mask.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="mask">Filter mask.</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007D0 RID: 2000 RVA: 0x000322DC File Offset: 0x000304DC
		public HImage MidrangeImage(HRegion mask, string margin)
		{
			IntPtr proc = HalconAPI.PreCall(1409);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, mask);
			HalconAPI.StoreS(proc, 0, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(mask);
			return result;
		}

		/// <summary>
		///   Smooth an image with an arbitrary rank mask.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="mask">Image whose region serves as filter mask.</param>
		/// <param name="number">Number of averaged pixels. Typical value:       Surface(Mask) / 2. Default: 5</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered output image.</returns>
		// Token: 0x060007D1 RID: 2001 RVA: 0x0003233C File Offset: 0x0003053C
		public HImage TrimmedMean(HRegion mask, int number, HTuple margin)
		{
			IntPtr proc = HalconAPI.PreCall(1410);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, mask);
			HalconAPI.StoreI(proc, 0, number);
			HalconAPI.Store(proc, 1, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(margin);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(mask);
			return result;
		}

		/// <summary>
		///   Smooth an image with an arbitrary rank mask.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="mask">Image whose region serves as filter mask.</param>
		/// <param name="number">Number of averaged pixels. Typical value:       Surface(Mask) / 2. Default: 5</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered output image.</returns>
		// Token: 0x060007D2 RID: 2002 RVA: 0x000323A8 File Offset: 0x000305A8
		public HImage TrimmedMean(HRegion mask, int number, string margin)
		{
			IntPtr proc = HalconAPI.PreCall(1410);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, mask);
			HalconAPI.StoreI(proc, 0, number);
			HalconAPI.StoreS(proc, 1, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(mask);
			return result;
		}

		/// <summary>
		///   Separated median filtering with rectangle masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskWidth">Width of rank mask. Default: 25</param>
		/// <param name="maskHeight">Height of rank mask. Default: 25</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Median filtered image.</returns>
		// Token: 0x060007D3 RID: 2003 RVA: 0x00032410 File Offset: 0x00030610
		public HImage MedianSeparate(int maskWidth, int maskHeight, HTuple margin)
		{
			IntPtr proc = HalconAPI.PreCall(1411);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.Store(proc, 2, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(margin);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Separated median filtering with rectangle masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskWidth">Width of rank mask. Default: 25</param>
		/// <param name="maskHeight">Height of rank mask. Default: 25</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Median filtered image.</returns>
		// Token: 0x060007D4 RID: 2004 RVA: 0x00032478 File Offset: 0x00030678
		public HImage MedianSeparate(int maskWidth, int maskHeight, string margin)
		{
			IntPtr proc = HalconAPI.PreCall(1411);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreS(proc, 2, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute a median filter with rectangular masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskWidth">Width of the filter mask. Default: 15</param>
		/// <param name="maskHeight">Height of the filter mask. Default: 15</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007D5 RID: 2005 RVA: 0x000324D8 File Offset: 0x000306D8
		public HImage MedianRect(int maskWidth, int maskHeight)
		{
			IntPtr proc = HalconAPI.PreCall(1412);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute a median filter with various masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskType">Filter mask type. Default: "circle"</param>
		/// <param name="radius">Radius of the filter mask. Default: 1</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007D6 RID: 2006 RVA: 0x00032530 File Offset: 0x00030730
		public HImage MedianImage(string maskType, int radius, HTuple margin)
		{
			IntPtr proc = HalconAPI.PreCall(1413);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, maskType);
			HalconAPI.StoreI(proc, 1, radius);
			HalconAPI.Store(proc, 2, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(margin);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute a median filter with various masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskType">Filter mask type. Default: "circle"</param>
		/// <param name="radius">Radius of the filter mask. Default: 1</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007D7 RID: 2007 RVA: 0x00032598 File Offset: 0x00030798
		public HImage MedianImage(string maskType, int radius, string margin)
		{
			IntPtr proc = HalconAPI.PreCall(1413);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, maskType);
			HalconAPI.StoreI(proc, 1, radius);
			HalconAPI.StoreS(proc, 2, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Weighted median filtering with different rank masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskType">Type of median mask. Default: "inner"</param>
		/// <param name="maskSize">mask size. Default: 3</param>
		/// <returns>Median filtered image.</returns>
		// Token: 0x060007D8 RID: 2008 RVA: 0x000325F8 File Offset: 0x000307F8
		public HImage MedianWeighted(string maskType, int maskSize)
		{
			IntPtr proc = HalconAPI.PreCall(1414);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, maskType);
			HalconAPI.StoreI(proc, 1, maskSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute a rank filter with rectangular masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskWidth">Width of the filter mask. Default: 15</param>
		/// <param name="maskHeight">Height of the filter mask. Default: 15</param>
		/// <param name="rank">Rank of the output gray value. Default: 5</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007D9 RID: 2009 RVA: 0x00032650 File Offset: 0x00030850
		public HImage RankRect(int maskWidth, int maskHeight, int rank)
		{
			IntPtr proc = HalconAPI.PreCall(1415);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreI(proc, 2, rank);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute a rank filter with arbitrary masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="mask">Filter mask.</param>
		/// <param name="rank">Rank of the output gray value. Default: 5</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007DA RID: 2010 RVA: 0x000326B0 File Offset: 0x000308B0
		public HImage RankImage(HRegion mask, int rank, HTuple margin)
		{
			IntPtr proc = HalconAPI.PreCall(1416);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, mask);
			HalconAPI.StoreI(proc, 0, rank);
			HalconAPI.Store(proc, 1, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(margin);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(mask);
			return result;
		}

		/// <summary>
		///   Compute a rank filter with arbitrary masks.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="mask">Filter mask.</param>
		/// <param name="rank">Rank of the output gray value. Default: 5</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007DB RID: 2011 RVA: 0x0003271C File Offset: 0x0003091C
		public HImage RankImage(HRegion mask, int rank, string margin)
		{
			IntPtr proc = HalconAPI.PreCall(1416);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, mask);
			HalconAPI.StoreI(proc, 0, rank);
			HalconAPI.StoreS(proc, 1, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(mask);
			return result;
		}

		/// <summary>
		///   Opening, Median and Closing with circle or rectangle mask.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskType">Shape of the mask. Default: "circle"</param>
		/// <param name="radius">Radius of the filter mask. Default: 1</param>
		/// <param name="modePercent">Filter Mode: 0 corresponds to a gray value opening , 50 corresponds to a median and 100 to a gray values closing. Default: 10</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered Image.</returns>
		// Token: 0x060007DC RID: 2012 RVA: 0x00032784 File Offset: 0x00030984
		public HImage DualRank(string maskType, int radius, int modePercent, HTuple margin)
		{
			IntPtr proc = HalconAPI.PreCall(1417);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, maskType);
			HalconAPI.StoreI(proc, 1, radius);
			HalconAPI.StoreI(proc, 2, modePercent);
			HalconAPI.Store(proc, 3, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(margin);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Opening, Median and Closing with circle or rectangle mask.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="maskType">Shape of the mask. Default: "circle"</param>
		/// <param name="radius">Radius of the filter mask. Default: 1</param>
		/// <param name="modePercent">Filter Mode: 0 corresponds to a gray value opening , 50 corresponds to a median and 100 to a gray values closing. Default: 10</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Filtered Image.</returns>
		// Token: 0x060007DD RID: 2013 RVA: 0x000327F4 File Offset: 0x000309F4
		public HImage DualRank(string maskType, int radius, int modePercent, string margin)
		{
			IntPtr proc = HalconAPI.PreCall(1417);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, maskType);
			HalconAPI.StoreI(proc, 1, radius);
			HalconAPI.StoreI(proc, 2, modePercent);
			HalconAPI.StoreS(proc, 3, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smooth by averaging.
		///   Instance represents: Image to be smoothed.
		/// </summary>
		/// <param name="maskWidth">Width of filter mask. Default: 9</param>
		/// <param name="maskHeight">Height of filter mask. Default: 9</param>
		/// <returns>Smoothed image.</returns>
		// Token: 0x060007DE RID: 2014 RVA: 0x00032860 File Offset: 0x00030A60
		public HImage MeanImage(int maskWidth, int maskHeight)
		{
			IntPtr proc = HalconAPI.PreCall(1418);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smooth an image using the binomial filter.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskWidth">Filter width. Default: 5</param>
		/// <param name="maskHeight">Filter height. Default: 5</param>
		/// <returns>Smoothed image.</returns>
		// Token: 0x060007DF RID: 2015 RVA: 0x000328B8 File Offset: 0x00030AB8
		public HImage BinomialFilter(int maskWidth, int maskHeight)
		{
			IntPtr proc = HalconAPI.PreCall(1420);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smooth an image using discrete Gaussian functions.
		///   Instance represents: Image to be smoothed.
		/// </summary>
		/// <param name="size">Required filter size. Default: 5</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007E0 RID: 2016 RVA: 0x00032910 File Offset: 0x00030B10
		public HImage GaussImage(int size)
		{
			IntPtr proc = HalconAPI.PreCall(1421);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, size);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smooth using discrete gauss functions.
		///   Instance represents: Image to be smoothed.
		/// </summary>
		/// <param name="size">Required filter size. Default: 5</param>
		/// <returns>Filtered image.</returns>
		// Token: 0x060007E1 RID: 2017 RVA: 0x00032960 File Offset: 0x00030B60
		public HImage GaussFilter(int size)
		{
			IntPtr proc = HalconAPI.PreCall(1422);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, size);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smooth an image in the spatial domain to suppress noise.
		///   Instance represents: Image to smooth.
		/// </summary>
		/// <param name="maskWidth">Width of filter mask. Default: 3</param>
		/// <param name="maskHeight">Height of filter mask. Default: 3</param>
		/// <param name="gap">Gap between local maximum/minimum and all other gray values of the neighborhood. Default: 1.0</param>
		/// <param name="mode">Replacement rule (1 = next minimum/maximum, 2 = average, 3 =median). Default: 3</param>
		/// <returns>Smoothed image.</returns>
		// Token: 0x060007E2 RID: 2018 RVA: 0x000329B0 File Offset: 0x00030BB0
		public HImage EliminateMinMax(int maskWidth, int maskHeight, double gap, int mode)
		{
			IntPtr proc = HalconAPI.PreCall(1423);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreD(proc, 2, gap);
			HalconAPI.StoreI(proc, 3, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Interpolate 2 video half images.
		///   Instance represents: Gray image consisting of two half images.
		/// </summary>
		/// <param name="mode">Instruction whether even or odd lines should be replaced/removed. Default: "odd"</param>
		/// <returns>Full image with interpolated/removed lines.</returns>
		// Token: 0x060007E3 RID: 2019 RVA: 0x00032A1C File Offset: 0x00030C1C
		public HImage FillInterlace(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1424);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return gray values with given rank from multiple channels.
		///   Instance represents: Multichannel gray image.
		/// </summary>
		/// <param name="rankIndex">Rank of the gray value images to return. Default: 2</param>
		/// <returns>Result of the rank function.</returns>
		// Token: 0x060007E4 RID: 2020 RVA: 0x00032A6C File Offset: 0x00030C6C
		public HImage RankN(int rankIndex)
		{
			IntPtr proc = HalconAPI.PreCall(1425);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, rankIndex);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Average gray values over several channels.
		///   Instance represents: Multichannel gray image.
		/// </summary>
		/// <returns>Result of averaging.</returns>
		// Token: 0x060007E5 RID: 2021 RVA: 0x00032ABC File Offset: 0x00030CBC
		public HImage MeanN()
		{
			IntPtr proc = HalconAPI.PreCall(1426);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Replace values outside of thresholds with average value.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskWidth">Width of filter mask. Default: 3</param>
		/// <param name="maskHeight">Height of filter mask. Default: 3</param>
		/// <param name="minThresh">Minimum gray value. Default: 1</param>
		/// <param name="maxThresh">Maximum gray value. Default: 254</param>
		/// <returns>Smoothed image.</returns>
		// Token: 0x060007E6 RID: 2022 RVA: 0x00032B04 File Offset: 0x00030D04
		public HImage EliminateSp(int maskWidth, int maskHeight, int minThresh, int maxThresh)
		{
			IntPtr proc = HalconAPI.PreCall(1427);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreI(proc, 2, minThresh);
			HalconAPI.StoreI(proc, 3, maxThresh);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Suppress salt and pepper noise.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskWidth">Width of filter mask. Default: 3</param>
		/// <param name="maskHeight">Height of filter mask. Default: 3</param>
		/// <param name="minThresh">Minimum gray value. Default: 1</param>
		/// <param name="maxThresh">Maximum gray value. Default: 254</param>
		/// <returns>Smoothed image.</returns>
		// Token: 0x060007E7 RID: 2023 RVA: 0x00032B70 File Offset: 0x00030D70
		public HImage MeanSp(int maskWidth, int maskHeight, int minThresh, int maxThresh)
		{
			IntPtr proc = HalconAPI.PreCall(1428);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreI(proc, 2, minThresh);
			HalconAPI.StoreI(proc, 3, maxThresh);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Find corners using the Sojka operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskSize">Required filter size. Default: 9</param>
		/// <param name="sigmaW">Sigma of the weight function according to the distance to the corner candidate. Default: 2.5</param>
		/// <param name="sigmaD">Sigma of the weight function for the distance to the ideal gray value edge. Default: 0.75</param>
		/// <param name="minGrad">Threshold for the magnitude of the gradient. Default: 30.0</param>
		/// <param name="minApparentness">Threshold for Apparentness. Default: 90.0</param>
		/// <param name="minAngle">Threshold for the direction change in a corner point (radians). Default: 0.5</param>
		/// <param name="subpix">Subpixel precise calculation of the corner points. Default: "false"</param>
		/// <param name="row">Row coordinates of the detected corner points.</param>
		/// <param name="column">Column coordinates of the detected corner points.</param>
		// Token: 0x060007E8 RID: 2024 RVA: 0x00032BDC File Offset: 0x00030DDC
		public void PointsSojka(int maskSize, HTuple sigmaW, HTuple sigmaD, HTuple minGrad, HTuple minApparentness, double minAngle, string subpix, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1429);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskSize);
			HalconAPI.Store(proc, 1, sigmaW);
			HalconAPI.Store(proc, 2, sigmaD);
			HalconAPI.Store(proc, 3, minGrad);
			HalconAPI.Store(proc, 4, minApparentness);
			HalconAPI.StoreD(proc, 5, minAngle);
			HalconAPI.StoreS(proc, 6, subpix);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigmaW);
			HalconAPI.UnpinTuple(sigmaD);
			HalconAPI.UnpinTuple(minGrad);
			HalconAPI.UnpinTuple(minApparentness);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Find corners using the Sojka operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskSize">Required filter size. Default: 9</param>
		/// <param name="sigmaW">Sigma of the weight function according to the distance to the corner candidate. Default: 2.5</param>
		/// <param name="sigmaD">Sigma of the weight function for the distance to the ideal gray value edge. Default: 0.75</param>
		/// <param name="minGrad">Threshold for the magnitude of the gradient. Default: 30.0</param>
		/// <param name="minApparentness">Threshold for Apparentness. Default: 90.0</param>
		/// <param name="minAngle">Threshold for the direction change in a corner point (radians). Default: 0.5</param>
		/// <param name="subpix">Subpixel precise calculation of the corner points. Default: "false"</param>
		/// <param name="row">Row coordinates of the detected corner points.</param>
		/// <param name="column">Column coordinates of the detected corner points.</param>
		// Token: 0x060007E9 RID: 2025 RVA: 0x00032C90 File Offset: 0x00030E90
		public void PointsSojka(int maskSize, double sigmaW, double sigmaD, double minGrad, double minApparentness, double minAngle, string subpix, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1429);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskSize);
			HalconAPI.StoreD(proc, 1, sigmaW);
			HalconAPI.StoreD(proc, 2, sigmaD);
			HalconAPI.StoreD(proc, 3, minGrad);
			HalconAPI.StoreD(proc, 4, minApparentness);
			HalconAPI.StoreD(proc, 5, minAngle);
			HalconAPI.StoreS(proc, 6, subpix);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Enhance circular dots in an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="diameter">Diameter of the dots to be enhanced. Default: 5</param>
		/// <param name="filterType">Enhance dark, light, or all dots. Default: "light"</param>
		/// <param name="pixelShift">Shift of the filter response. Default: 0</param>
		/// <returns>Output image.</returns>
		// Token: 0x060007EA RID: 2026 RVA: 0x00032D28 File Offset: 0x00030F28
		public HImage DotsImage(int diameter, string filterType, int pixelShift)
		{
			IntPtr proc = HalconAPI.PreCall(1430);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, diameter);
			HalconAPI.StoreS(proc, 1, filterType);
			HalconAPI.StoreI(proc, 2, pixelShift);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Subpixel precise detection of local minima in an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Method for the calculation of the partial derivatives. Default: "facet"</param>
		/// <param name="sigma">Sigma of the Gaussian. If Filter is 'facet', Sigma may be 0.0 to avoid the smoothing of the input image.</param>
		/// <param name="threshold">Minimum absolute value of the eigenvalues of the Hessian matrix. Default: 5.0</param>
		/// <param name="row">Row coordinates of the detected minima.</param>
		/// <param name="column">Column coordinates of the detected minima.</param>
		// Token: 0x060007EB RID: 2027 RVA: 0x00032D88 File Offset: 0x00030F88
		public void LocalMinSubPix(string filter, double sigma, double threshold, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1431);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Subpixel precise detection of local maxima in an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Method for the calculation of the partial derivatives. Default: "facet"</param>
		/// <param name="sigma">Sigma of the Gaussian. If Filter is 'facet', Sigma may be 0.0 to avoid the smoothing of the input image.</param>
		/// <param name="threshold">Minimum absolute value of the eigenvalues of the Hessian matrix. Default: 5.0</param>
		/// <param name="row">Row coordinates of the detected maxima.</param>
		/// <param name="column">Column coordinates of the detected maxima.</param>
		// Token: 0x060007EC RID: 2028 RVA: 0x00032DFC File Offset: 0x00030FFC
		public void LocalMaxSubPix(string filter, double sigma, double threshold, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1432);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Subpixel precise detection of saddle points in an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Method for the calculation of the partial derivatives. Default: "facet"</param>
		/// <param name="sigma">Sigma of the Gaussian. If Filter is 'facet', Sigma may be 0.0 to avoid the smoothing of the input image.</param>
		/// <param name="threshold">Minimum absolute value of the eigenvalues of the Hessian matrix. Default: 5.0</param>
		/// <param name="row">Row coordinates of the detected saddle points.</param>
		/// <param name="column">Column coordinates of the detected saddle points.</param>
		// Token: 0x060007ED RID: 2029 RVA: 0x00032E70 File Offset: 0x00031070
		public void SaddlePointsSubPix(string filter, double sigma, double threshold, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1433);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Subpixel precise detection of critical points in an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Method for the calculation of the partial derivatives. Default: "facet"</param>
		/// <param name="sigma">Sigma of the Gaussian. If Filter is 'facet', Sigma may be 0.0 to avoid the smoothing of the input image.</param>
		/// <param name="threshold">Minimum absolute value of the eigenvalues of the Hessian matrix. Default: 5.0</param>
		/// <param name="rowMin">Row coordinates of the detected minima.</param>
		/// <param name="columnMin">Column coordinates of the detected minima.</param>
		/// <param name="rowMax">Row coordinates of the detected maxima.</param>
		/// <param name="columnMax">Column coordinates of the detected maxima.</param>
		/// <param name="rowSaddle">Row coordinates of the detected saddle points.</param>
		/// <param name="columnSaddle">Column coordinates of the detected saddle points.</param>
		// Token: 0x060007EE RID: 2030 RVA: 0x00032EE4 File Offset: 0x000310E4
		public void CriticalPointsSubPix(string filter, double sigma, double threshold, out HTuple rowMin, out HTuple columnMin, out HTuple rowMax, out HTuple columnMax, out HTuple rowSaddle, out HTuple columnSaddle)
		{
			IntPtr proc = HalconAPI.PreCall(1434);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnMin);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out rowMax);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out columnMax);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out rowSaddle);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out columnSaddle);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Detect points of interest using the Harris operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigmaGrad">Amount of smoothing used for the calculation of the gradient. Default: 0.7</param>
		/// <param name="sigmaSmooth">Amount of smoothing used for the integration of the gradients. Default: 2.0</param>
		/// <param name="alpha">Weight of the squared trace of the squared gradient matrix. Default: 0.08</param>
		/// <param name="threshold">Minimum filter response for the points. Default: 1000.0</param>
		/// <param name="row">Row coordinates of the detected points.</param>
		/// <param name="column">Column coordinates of the detected points.</param>
		// Token: 0x060007EF RID: 2031 RVA: 0x00032FA8 File Offset: 0x000311A8
		public void PointsHarris(double sigmaGrad, double sigmaSmooth, double alpha, HTuple threshold, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1435);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigmaGrad);
			HalconAPI.StoreD(proc, 1, sigmaSmooth);
			HalconAPI.StoreD(proc, 2, alpha);
			HalconAPI.Store(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(threshold);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Detect points of interest using the Harris operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigmaGrad">Amount of smoothing used for the calculation of the gradient. Default: 0.7</param>
		/// <param name="sigmaSmooth">Amount of smoothing used for the integration of the gradients. Default: 2.0</param>
		/// <param name="alpha">Weight of the squared trace of the squared gradient matrix. Default: 0.08</param>
		/// <param name="threshold">Minimum filter response for the points. Default: 1000.0</param>
		/// <param name="row">Row coordinates of the detected points.</param>
		/// <param name="column">Column coordinates of the detected points.</param>
		// Token: 0x060007F0 RID: 2032 RVA: 0x0003302C File Offset: 0x0003122C
		public void PointsHarris(double sigmaGrad, double sigmaSmooth, double alpha, double threshold, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1435);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigmaGrad);
			HalconAPI.StoreD(proc, 1, sigmaSmooth);
			HalconAPI.StoreD(proc, 2, alpha);
			HalconAPI.StoreD(proc, 3, threshold);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Detect points of interest using the binomial approximation of the Harris operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskSizeGrad">Amount of binomial smoothing used for the calculation of the gradient. Default: 5</param>
		/// <param name="maskSizeSmooth">Amount of smoothing used for the integration of the gradients. Default: 15</param>
		/// <param name="alpha">Weight of the squared trace of the squared gradient matrix. Default: 0.08</param>
		/// <param name="threshold">Minimum filter response for the points. Default: 1000.0</param>
		/// <param name="subpix">Turn on or off subpixel refinement. Default: "on"</param>
		/// <param name="row">Row coordinates of the detected points.</param>
		/// <param name="column">Column coordinates of the detected points.</param>
		// Token: 0x060007F1 RID: 2033 RVA: 0x000330AC File Offset: 0x000312AC
		public void PointsHarrisBinomial(int maskSizeGrad, int maskSizeSmooth, double alpha, HTuple threshold, string subpix, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1436);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskSizeGrad);
			HalconAPI.StoreI(proc, 1, maskSizeSmooth);
			HalconAPI.StoreD(proc, 2, alpha);
			HalconAPI.Store(proc, 3, threshold);
			HalconAPI.StoreS(proc, 4, subpix);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(threshold);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Detect points of interest using the binomial approximation of the Harris operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskSizeGrad">Amount of binomial smoothing used for the calculation of the gradient. Default: 5</param>
		/// <param name="maskSizeSmooth">Amount of smoothing used for the integration of the gradients. Default: 15</param>
		/// <param name="alpha">Weight of the squared trace of the squared gradient matrix. Default: 0.08</param>
		/// <param name="threshold">Minimum filter response for the points. Default: 1000.0</param>
		/// <param name="subpix">Turn on or off subpixel refinement. Default: "on"</param>
		/// <param name="row">Row coordinates of the detected points.</param>
		/// <param name="column">Column coordinates of the detected points.</param>
		// Token: 0x060007F2 RID: 2034 RVA: 0x0003313C File Offset: 0x0003133C
		public void PointsHarrisBinomial(int maskSizeGrad, int maskSizeSmooth, double alpha, double threshold, string subpix, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1436);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskSizeGrad);
			HalconAPI.StoreI(proc, 1, maskSizeSmooth);
			HalconAPI.StoreD(proc, 2, alpha);
			HalconAPI.StoreD(proc, 3, threshold);
			HalconAPI.StoreS(proc, 4, subpix);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Detect points of interest using the Lepetit operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="radius">Radius of the circle. Default: 3</param>
		/// <param name="checkNeighbor">Number of checked neighbors on the circle. Default: 1</param>
		/// <param name="minCheckNeighborDiff">Threshold of grayvalue difference to each circle point. Default: 15</param>
		/// <param name="minScore">Threshold of grayvalue difference to all circle points. Default: 30</param>
		/// <param name="subpix">Subpixel accuracy of point coordinates. Default: "interpolation"</param>
		/// <param name="row">Row-coordinates of the detected points.</param>
		/// <param name="column">Column-coordinates of the detected points.</param>
		// Token: 0x060007F3 RID: 2035 RVA: 0x000331C4 File Offset: 0x000313C4
		public void PointsLepetit(int radius, int checkNeighbor, int minCheckNeighborDiff, int minScore, string subpix, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1437);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, radius);
			HalconAPI.StoreI(proc, 1, checkNeighbor);
			HalconAPI.StoreI(proc, 2, minCheckNeighborDiff);
			HalconAPI.StoreI(proc, 3, minScore);
			HalconAPI.StoreS(proc, 4, subpix);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, num, out row);
			num = HTuple.LoadNew(proc, 1, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Detect points of interest using the Foerstner operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigmaGrad">Amount of smoothing used for the calculation of the gradient. If Smoothing is 'mean', SigmaGrad is ignored. Default: 1.0</param>
		/// <param name="sigmaInt">Amount of smoothing used for the integration of the gradients. Default: 2.0</param>
		/// <param name="sigmaPoints">Amount of smoothing used in the optimization functions. Default: 3.0</param>
		/// <param name="threshInhom">Threshold for the segmentation of inhomogeneous image areas. Default: 200</param>
		/// <param name="threshShape">Threshold for the segmentation of point areas. Default: 0.3</param>
		/// <param name="smoothing">Used smoothing method. Default: "gauss"</param>
		/// <param name="eliminateDoublets">Elimination of multiply detected points. Default: "false"</param>
		/// <param name="rowJunctions">Row coordinates of the detected junction points.</param>
		/// <param name="columnJunctions">Column coordinates of the detected junction points.</param>
		/// <param name="coRRJunctions">Row part of the covariance matrix of the detected junction points.</param>
		/// <param name="coRCJunctions">Mixed part of the covariance matrix of the detected junction points.</param>
		/// <param name="coCCJunctions">Column part of the covariance matrix of the detected junction points.</param>
		/// <param name="rowArea">Row coordinates of the detected area points.</param>
		/// <param name="columnArea">Column coordinates of the detected area points.</param>
		/// <param name="coRRArea">Row part of the covariance matrix of the detected area points.</param>
		/// <param name="coRCArea">Mixed part of the covariance matrix of the detected area points.</param>
		/// <param name="coCCArea">Column part of the covariance matrix of the detected area points.</param>
		// Token: 0x060007F4 RID: 2036 RVA: 0x00033248 File Offset: 0x00031448
		public void PointsFoerstner(HTuple sigmaGrad, HTuple sigmaInt, HTuple sigmaPoints, HTuple threshInhom, double threshShape, string smoothing, string eliminateDoublets, out HTuple rowJunctions, out HTuple columnJunctions, out HTuple coRRJunctions, out HTuple coRCJunctions, out HTuple coCCJunctions, out HTuple rowArea, out HTuple columnArea, out HTuple coRRArea, out HTuple coRCArea, out HTuple coCCArea)
		{
			IntPtr proc = HalconAPI.PreCall(1438);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sigmaGrad);
			HalconAPI.Store(proc, 1, sigmaInt);
			HalconAPI.Store(proc, 2, sigmaPoints);
			HalconAPI.Store(proc, 3, threshInhom);
			HalconAPI.StoreD(proc, 4, threshShape);
			HalconAPI.StoreS(proc, 5, smoothing);
			HalconAPI.StoreS(proc, 6, eliminateDoublets);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigmaGrad);
			HalconAPI.UnpinTuple(sigmaInt);
			HalconAPI.UnpinTuple(sigmaPoints);
			HalconAPI.UnpinTuple(threshInhom);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowJunctions);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnJunctions);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out coRRJunctions);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out coRCJunctions);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out coCCJunctions);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out rowArea);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out columnArea);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out coRRArea);
			num = HTuple.LoadNew(proc, 8, HTupleType.DOUBLE, num, out coRCArea);
			num = HTuple.LoadNew(proc, 9, HTupleType.DOUBLE, num, out coCCArea);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Detect points of interest using the Foerstner operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigmaGrad">Amount of smoothing used for the calculation of the gradient. If Smoothing is 'mean', SigmaGrad is ignored. Default: 1.0</param>
		/// <param name="sigmaInt">Amount of smoothing used for the integration of the gradients. Default: 2.0</param>
		/// <param name="sigmaPoints">Amount of smoothing used in the optimization functions. Default: 3.0</param>
		/// <param name="threshInhom">Threshold for the segmentation of inhomogeneous image areas. Default: 200</param>
		/// <param name="threshShape">Threshold for the segmentation of point areas. Default: 0.3</param>
		/// <param name="smoothing">Used smoothing method. Default: "gauss"</param>
		/// <param name="eliminateDoublets">Elimination of multiply detected points. Default: "false"</param>
		/// <param name="rowJunctions">Row coordinates of the detected junction points.</param>
		/// <param name="columnJunctions">Column coordinates of the detected junction points.</param>
		/// <param name="coRRJunctions">Row part of the covariance matrix of the detected junction points.</param>
		/// <param name="coRCJunctions">Mixed part of the covariance matrix of the detected junction points.</param>
		/// <param name="coCCJunctions">Column part of the covariance matrix of the detected junction points.</param>
		/// <param name="rowArea">Row coordinates of the detected area points.</param>
		/// <param name="columnArea">Column coordinates of the detected area points.</param>
		/// <param name="coRRArea">Row part of the covariance matrix of the detected area points.</param>
		/// <param name="coRCArea">Mixed part of the covariance matrix of the detected area points.</param>
		/// <param name="coCCArea">Column part of the covariance matrix of the detected area points.</param>
		// Token: 0x060007F5 RID: 2037 RVA: 0x0003339C File Offset: 0x0003159C
		public void PointsFoerstner(double sigmaGrad, double sigmaInt, double sigmaPoints, double threshInhom, double threshShape, string smoothing, string eliminateDoublets, out HTuple rowJunctions, out HTuple columnJunctions, out HTuple coRRJunctions, out HTuple coRCJunctions, out HTuple coCCJunctions, out HTuple rowArea, out HTuple columnArea, out HTuple coRRArea, out HTuple coRCArea, out HTuple coCCArea)
		{
			IntPtr proc = HalconAPI.PreCall(1438);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigmaGrad);
			HalconAPI.StoreD(proc, 1, sigmaInt);
			HalconAPI.StoreD(proc, 2, sigmaPoints);
			HalconAPI.StoreD(proc, 3, threshInhom);
			HalconAPI.StoreD(proc, 4, threshShape);
			HalconAPI.StoreS(proc, 5, smoothing);
			HalconAPI.StoreS(proc, 6, eliminateDoublets);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowJunctions);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnJunctions);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out coRRJunctions);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out coRCJunctions);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out coCCJunctions);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out rowArea);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out columnArea);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out coRRArea);
			num = HTuple.LoadNew(proc, 8, HTupleType.DOUBLE, num, out coRCArea);
			num = HTuple.LoadNew(proc, 9, HTupleType.DOUBLE, num, out coCCArea);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Estimate the image noise from a single image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="method">Method to estimate the image noise. Default: "foerstner"</param>
		/// <param name="percent">Percentage of used image points. Default: 20</param>
		/// <returns>Standard deviation of the image noise.</returns>
		// Token: 0x060007F6 RID: 2038 RVA: 0x000334D8 File Offset: 0x000316D8
		public HTuple EstimateNoise(string method, HTuple percent)
		{
			IntPtr proc = HalconAPI.PreCall(1439);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.Store(proc, 1, percent);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(percent);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Estimate the image noise from a single image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="method">Method to estimate the image noise. Default: "foerstner"</param>
		/// <param name="percent">Percentage of used image points. Default: 20</param>
		/// <returns>Standard deviation of the image noise.</returns>
		// Token: 0x060007F7 RID: 2039 RVA: 0x00033538 File Offset: 0x00031738
		public double EstimateNoise(string method, double percent)
		{
			IntPtr proc = HalconAPI.PreCall(1439);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, method);
			HalconAPI.StoreD(proc, 1, percent);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the noise distribution of an image.
		///   Instance represents: Corresponding image.
		/// </summary>
		/// <param name="constRegion">Region from which the noise distribution is to be estimated.</param>
		/// <param name="filterSize">Size of the mean filter. Default: 21</param>
		/// <returns>Noise distribution of all input regions.</returns>
		// Token: 0x060007F8 RID: 2040 RVA: 0x00033590 File Offset: 0x00031790
		public HTuple NoiseDistributionMean(HRegion constRegion, int filterSize)
		{
			IntPtr proc = HalconAPI.PreCall(1440);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, constRegion);
			HalconAPI.StoreI(proc, 0, filterSize);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(constRegion);
			return result;
		}

		/// <summary>
		///   Add noise to an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="amp">Maximum noise amplitude. Default: 60.0</param>
		/// <returns>Noisy image.</returns>
		// Token: 0x060007F9 RID: 2041 RVA: 0x000335F0 File Offset: 0x000317F0
		public HImage AddNoiseWhite(double amp)
		{
			IntPtr proc = HalconAPI.PreCall(1441);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, amp);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add noise to an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="distribution">Noise distribution.</param>
		/// <returns>Noisy image.</returns>
		// Token: 0x060007FA RID: 2042 RVA: 0x00033640 File Offset: 0x00031840
		public HImage AddNoiseDistribution(HTuple distribution)
		{
			IntPtr proc = HalconAPI.PreCall(1442);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, distribution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(distribution);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate standard deviation over several channels.
		///   Instance represents: Multichannel gray image.
		/// </summary>
		/// <returns>Result of calculation.</returns>
		// Token: 0x060007FB RID: 2043 RVA: 0x00033698 File Offset: 0x00031898
		public HImage DeviationN()
		{
			IntPtr proc = HalconAPI.PreCall(1445);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform an inpainting by texture propagation.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">Inpainting region.</param>
		/// <param name="maskSize">Size of the inpainting blocks. Default: 9</param>
		/// <param name="searchSize">Size of the search window. Default: 30</param>
		/// <param name="anisotropy">Influence of the edge amplitude on the inpainting order. Default: 1.0</param>
		/// <param name="postIteration">Post-iteration for artifact reduction. Default: "none"</param>
		/// <param name="smoothness">Gray value tolerance for post-iteration. Default: 1.0</param>
		/// <returns>Output image.</returns>
		// Token: 0x060007FC RID: 2044 RVA: 0x000336E0 File Offset: 0x000318E0
		public HImage InpaintingTexture(HRegion region, int maskSize, int searchSize, double anisotropy, string postIteration, double smoothness)
		{
			IntPtr proc = HalconAPI.PreCall(1446);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreI(proc, 0, maskSize);
			HalconAPI.StoreI(proc, 1, searchSize);
			HalconAPI.StoreD(proc, 2, anisotropy);
			HalconAPI.StoreS(proc, 3, postIteration);
			HalconAPI.StoreD(proc, 4, smoothness);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Perform an inpainting by coherence transport.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">Inpainting region.</param>
		/// <param name="epsilon">Radius of the pixel neighborhood. Default: 5.0</param>
		/// <param name="kappa">Sharpness parameter in percent. Default: 25.0</param>
		/// <param name="sigma">Pre-smoothing parameter. Default: 1.41</param>
		/// <param name="rho">Smoothing parameter for the direction estimation. Default: 4.0</param>
		/// <param name="channelCoefficients">Channel weights. Default: 1</param>
		/// <returns>Output image.</returns>
		// Token: 0x060007FD RID: 2045 RVA: 0x00033764 File Offset: 0x00031964
		public HImage InpaintingCt(HRegion region, double epsilon, double kappa, double sigma, double rho, HTuple channelCoefficients)
		{
			IntPtr proc = HalconAPI.PreCall(1447);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.StoreD(proc, 1, kappa);
			HalconAPI.StoreD(proc, 2, sigma);
			HalconAPI.StoreD(proc, 3, rho);
			HalconAPI.Store(proc, 4, channelCoefficients);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(channelCoefficients);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Perform an inpainting by coherence transport.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">Inpainting region.</param>
		/// <param name="epsilon">Radius of the pixel neighborhood. Default: 5.0</param>
		/// <param name="kappa">Sharpness parameter in percent. Default: 25.0</param>
		/// <param name="sigma">Pre-smoothing parameter. Default: 1.41</param>
		/// <param name="rho">Smoothing parameter for the direction estimation. Default: 4.0</param>
		/// <param name="channelCoefficients">Channel weights. Default: 1</param>
		/// <returns>Output image.</returns>
		// Token: 0x060007FE RID: 2046 RVA: 0x000337EC File Offset: 0x000319EC
		public HImage InpaintingCt(HRegion region, double epsilon, double kappa, double sigma, double rho, double channelCoefficients)
		{
			IntPtr proc = HalconAPI.PreCall(1447);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.StoreD(proc, 1, kappa);
			HalconAPI.StoreD(proc, 2, sigma);
			HalconAPI.StoreD(proc, 3, rho);
			HalconAPI.StoreD(proc, 4, channelCoefficients);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Perform an inpainting by smoothing of level lines.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">Inpainting region.</param>
		/// <param name="sigma">Smoothing for derivative operator. Default: 0.5</param>
		/// <param name="theta">Time step. Default: 0.5</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <returns>Output image.</returns>
		// Token: 0x060007FF RID: 2047 RVA: 0x00033870 File Offset: 0x00031A70
		public HImage InpaintingMcf(HRegion region, double sigma, double theta, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(1448);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, theta);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Perform an inpainting by coherence enhancing diffusion.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">Inpainting region.</param>
		/// <param name="sigma">Smoothing for derivative operator. Default: 0.5</param>
		/// <param name="rho">Smoothing for diffusion coefficients. Default: 3.0</param>
		/// <param name="theta">Time step. Default: 0.5</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000800 RID: 2048 RVA: 0x000338E0 File Offset: 0x00031AE0
		public HImage InpaintingCed(HRegion region, double sigma, double rho, double theta, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(1449);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, rho);
			HalconAPI.StoreD(proc, 2, theta);
			HalconAPI.StoreI(proc, 3, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Perform an inpainting by anisotropic diffusion.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">Inpainting region.</param>
		/// <param name="mode">Type of edge sharpening algorithm. Default: "weickert"</param>
		/// <param name="contrast">Contrast parameter. Default: 5.0</param>
		/// <param name="theta">Step size. Default: 0.5</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <param name="rho">Smoothing coefficient for edge information. Default: 3.0</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000801 RID: 2049 RVA: 0x00033958 File Offset: 0x00031B58
		public HImage InpaintingAniso(HRegion region, string mode, double contrast, double theta, int iterations, double rho)
		{
			IntPtr proc = HalconAPI.PreCall(1450);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreD(proc, 1, contrast);
			HalconAPI.StoreD(proc, 2, theta);
			HalconAPI.StoreI(proc, 3, iterations);
			HalconAPI.StoreD(proc, 4, rho);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Perform a harmonic interpolation on an image region.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="region">Inpainting region.</param>
		/// <param name="precision">Computational accuracy. Default: 0.001</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000802 RID: 2050 RVA: 0x000339DC File Offset: 0x00031BDC
		public HImage HarmonicInterpolation(HRegion region, double precision)
		{
			IntPtr proc = HalconAPI.PreCall(1451);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.StoreD(proc, 0, precision);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Expand the domain of an image and set the gray values in the expanded domain.
		///   Instance represents: Input image with domain to be expanded.
		/// </summary>
		/// <param name="expansionRange">Radius of the gray value expansion, measured in pixels. Default: 2</param>
		/// <returns>Output image with new gray values in the expanded domain.</returns>
		// Token: 0x06000803 RID: 2051 RVA: 0x00033A3C File Offset: 0x00031C3C
		public HImage ExpandDomainGray(int expansionRange)
		{
			IntPtr proc = HalconAPI.PreCall(1452);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, expansionRange);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the topographic primal sketch of an image.
		///   Instance represents: Image for which the topographic primal sketch is to be computed.
		/// </summary>
		/// <returns>Label image containing the 11 classes.</returns>
		// Token: 0x06000804 RID: 2052 RVA: 0x00033A8C File Offset: 0x00031C8C
		public HImage TopographicSketch()
		{
			IntPtr proc = HalconAPI.PreCall(1453);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute an affine transformation of the color values of a multichannel image.
		///   Instance represents: Multichannel input image.
		/// </summary>
		/// <param name="transMat">Transformation matrix for the color values.</param>
		/// <returns>Multichannel output image.</returns>
		// Token: 0x06000805 RID: 2053 RVA: 0x00033AD4 File Offset: 0x00031CD4
		public HImage LinearTransColor(HTuple transMat)
		{
			IntPtr proc = HalconAPI.PreCall(1454);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, transMat);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(transMat);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the transformation matrix of the principal component analysis of multichannel images.
		///   Instance represents: Multichannel input image.
		/// </summary>
		/// <param name="transInv">Transformation matrix for the computation of the inverse PCA.</param>
		/// <param name="mean">Mean gray value of the channels.</param>
		/// <param name="cov">Covariance matrix of the channels.</param>
		/// <param name="infoPerComp">Information content of the transformed channels.</param>
		/// <returns>Transformation matrix for the computation of the PCA.</returns>
		// Token: 0x06000806 RID: 2054 RVA: 0x00033B2C File Offset: 0x00031D2C
		public HTuple GenPrincipalCompTrans(out HTuple transInv, out HTuple mean, out HTuple cov, out HTuple infoPerComp)
		{
			IntPtr proc = HalconAPI.PreCall(1455);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out transInv);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out mean);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out cov);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out infoPerComp);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the principal components of multichannel images.
		///   Instance represents: Multichannel input image.
		/// </summary>
		/// <param name="infoPerComp">Information content of each output channel.</param>
		/// <returns>Multichannel output image.</returns>
		// Token: 0x06000807 RID: 2055 RVA: 0x00033BC4 File Offset: 0x00031DC4
		public HImage PrincipalComp(out HTuple infoPerComp)
		{
			IntPtr proc = HalconAPI.PreCall(1456);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out infoPerComp);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the fuzzy entropy of regions.
		///   Instance represents: Input image containing the fuzzy membership values.
		/// </summary>
		/// <param name="regions">Regions for which the fuzzy entropy is to be calculated.</param>
		/// <param name="apar">Start of the fuzzy function. Default: 0</param>
		/// <param name="cpar">End of the fuzzy function. Default: 255</param>
		/// <returns>Fuzzy entropy of a region.</returns>
		// Token: 0x06000808 RID: 2056 RVA: 0x00033C20 File Offset: 0x00031E20
		public HTuple FuzzyEntropy(HRegion regions, int apar, int cpar)
		{
			IntPtr proc = HalconAPI.PreCall(1457);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreI(proc, 0, apar);
			HalconAPI.StoreI(proc, 1, cpar);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the fuzzy perimeter of a region.
		///   Instance represents: Input image containing the fuzzy membership values.
		/// </summary>
		/// <param name="regions">Regions for which the fuzzy perimeter is to be calculated.</param>
		/// <param name="apar">Start of the fuzzy function. Default: 0</param>
		/// <param name="cpar">End of the fuzzy function. Default: 255</param>
		/// <returns>Fuzzy perimeter of a region.</returns>
		// Token: 0x06000809 RID: 2057 RVA: 0x00033C88 File Offset: 0x00031E88
		public HTuple FuzzyPerimeter(HRegion regions, int apar, int cpar)
		{
			IntPtr proc = HalconAPI.PreCall(1458);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreI(proc, 0, apar);
			HalconAPI.StoreI(proc, 1, cpar);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Perform a gray value closing with a selected mask.
		///   Instance represents: Image for which the minimum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the minimum gray values.</returns>
		// Token: 0x0600080A RID: 2058 RVA: 0x00033CF0 File Offset: 0x00031EF0
		public HImage GrayClosingShape(HTuple maskHeight, HTuple maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1459);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, maskHeight);
			HalconAPI.Store(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(maskHeight);
			HalconAPI.UnpinTuple(maskWidth);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a gray value closing with a selected mask.
		///   Instance represents: Image for which the minimum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the minimum gray values.</returns>
		// Token: 0x0600080B RID: 2059 RVA: 0x00033D5C File Offset: 0x00031F5C
		public HImage GrayClosingShape(double maskHeight, double maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1459);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maskHeight);
			HalconAPI.StoreD(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a gray value opening with a selected mask.
		///   Instance represents: Image for which the minimum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the minimum gray values.</returns>
		// Token: 0x0600080C RID: 2060 RVA: 0x00033DBC File Offset: 0x00031FBC
		public HImage GrayOpeningShape(HTuple maskHeight, HTuple maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1460);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, maskHeight);
			HalconAPI.Store(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(maskHeight);
			HalconAPI.UnpinTuple(maskWidth);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a gray value opening with a selected mask.
		///   Instance represents: Image for which the minimum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the minimum gray values.</returns>
		// Token: 0x0600080D RID: 2061 RVA: 0x00033E28 File Offset: 0x00032028
		public HImage GrayOpeningShape(double maskHeight, double maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1460);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maskHeight);
			HalconAPI.StoreD(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the minimum gray value within a selected mask.
		///   Instance represents: Image for which the minimum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the minimum gray values.</returns>
		// Token: 0x0600080E RID: 2062 RVA: 0x00033E88 File Offset: 0x00032088
		public HImage GrayErosionShape(HTuple maskHeight, HTuple maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1461);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, maskHeight);
			HalconAPI.Store(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(maskHeight);
			HalconAPI.UnpinTuple(maskWidth);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the minimum gray value within a selected mask.
		///   Instance represents: Image for which the minimum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the minimum gray values.</returns>
		// Token: 0x0600080F RID: 2063 RVA: 0x00033EF4 File Offset: 0x000320F4
		public HImage GrayErosionShape(double maskHeight, double maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1461);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maskHeight);
			HalconAPI.StoreD(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the maximum gray value within a selected mask.
		///   Instance represents: Image for which the maximum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the maximum gray values.</returns>
		// Token: 0x06000810 RID: 2064 RVA: 0x00033F54 File Offset: 0x00032154
		public HImage GrayDilationShape(HTuple maskHeight, HTuple maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1462);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, maskHeight);
			HalconAPI.Store(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(maskHeight);
			HalconAPI.UnpinTuple(maskWidth);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the maximum gray value within a selected mask.
		///   Instance represents: Image for which the maximum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <param name="maskShape">Shape of the mask. Default: "octagon"</param>
		/// <returns>Image containing the maximum gray values.</returns>
		// Token: 0x06000811 RID: 2065 RVA: 0x00033FC0 File Offset: 0x000321C0
		public HImage GrayDilationShape(double maskHeight, double maskWidth, string maskShape)
		{
			IntPtr proc = HalconAPI.PreCall(1462);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maskHeight);
			HalconAPI.StoreD(proc, 1, maskWidth);
			HalconAPI.StoreS(proc, 2, maskShape);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the gray value range within a rectangle.
		///   Instance represents: Image for which the gray value range is to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <returns>Image containing the gray value range.</returns>
		// Token: 0x06000812 RID: 2066 RVA: 0x00034020 File Offset: 0x00032220
		public HImage GrayRangeRect(int maskHeight, int maskWidth)
		{
			IntPtr proc = HalconAPI.PreCall(1463);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskHeight);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a gray value closing with a rectangular mask.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <returns>Gray-closed image.</returns>
		// Token: 0x06000813 RID: 2067 RVA: 0x00034078 File Offset: 0x00032278
		public HImage GrayClosingRect(int maskHeight, int maskWidth)
		{
			IntPtr proc = HalconAPI.PreCall(1464);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskHeight);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a gray value opening with a rectangular mask.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <returns>Gray-opened image.</returns>
		// Token: 0x06000814 RID: 2068 RVA: 0x000340D0 File Offset: 0x000322D0
		public HImage GrayOpeningRect(int maskHeight, int maskWidth)
		{
			IntPtr proc = HalconAPI.PreCall(1465);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskHeight);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the minimum gray value within a rectangle.
		///   Instance represents: Image for which the minimum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <returns>Image containing the minimum gray values.</returns>
		// Token: 0x06000815 RID: 2069 RVA: 0x00034128 File Offset: 0x00032328
		public HImage GrayErosionRect(int maskHeight, int maskWidth)
		{
			IntPtr proc = HalconAPI.PreCall(1466);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskHeight);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the maximum gray value within a rectangle.
		///   Instance represents: Image for which the maximum gray values are to be calculated.
		/// </summary>
		/// <param name="maskHeight">Height of the filter mask. Default: 11</param>
		/// <param name="maskWidth">Width of the filter mask. Default: 11</param>
		/// <returns>Image containing the maximum gray values.</returns>
		// Token: 0x06000816 RID: 2070 RVA: 0x00034180 File Offset: 0x00032380
		public HImage GrayDilationRect(int maskHeight, int maskWidth)
		{
			IntPtr proc = HalconAPI.PreCall(1467);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskHeight);
			HalconAPI.StoreI(proc, 1, maskWidth);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Thinning of gray value images.
		///   Instance represents: Image to be thinned.
		/// </summary>
		/// <returns>Thinned image.</returns>
		// Token: 0x06000817 RID: 2071 RVA: 0x000341D8 File Offset: 0x000323D8
		public HImage GraySkeleton()
		{
			IntPtr proc = HalconAPI.PreCall(1468);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an image with a gray-value look-up-table
		///   Instance represents: Image whose gray values are to be transformed.
		/// </summary>
		/// <param name="lut">Table containing the transformation.</param>
		/// <returns>Transformed image.</returns>
		// Token: 0x06000818 RID: 2072 RVA: 0x00034220 File Offset: 0x00032420
		public HImage LutTrans(HTuple lut)
		{
			IntPtr proc = HalconAPI.PreCall(1469);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, lut);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(lut);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the correlation between an image and an arbitrary filter mask
		///   Instance represents: Images for which the correlation will be calculated.
		/// </summary>
		/// <param name="filterMask">Filter mask as file name or tuple. Default: "sobel"</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Result of the correlation.</returns>
		// Token: 0x06000819 RID: 2073 RVA: 0x00034278 File Offset: 0x00032478
		public HImage ConvolImage(HTuple filterMask, HTuple margin)
		{
			IntPtr proc = HalconAPI.PreCall(1470);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, filterMask);
			HalconAPI.Store(proc, 1, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(filterMask);
			HalconAPI.UnpinTuple(margin);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the correlation between an image and an arbitrary filter mask
		///   Instance represents: Images for which the correlation will be calculated.
		/// </summary>
		/// <param name="filterMask">Filter mask as file name or tuple. Default: "sobel"</param>
		/// <param name="margin">Border treatment. Default: "mirrored"</param>
		/// <returns>Result of the correlation.</returns>
		// Token: 0x0600081A RID: 2074 RVA: 0x000342DC File Offset: 0x000324DC
		public HImage ConvolImage(string filterMask, string margin)
		{
			IntPtr proc = HalconAPI.PreCall(1470);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterMask);
			HalconAPI.StoreS(proc, 1, margin);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert the type of an image.
		///   Instance represents: Image whose image type is to be changed.
		/// </summary>
		/// <param name="newType">Desired image type (i.e., type of the gray values). Default: "byte"</param>
		/// <returns>Converted image.</returns>
		// Token: 0x0600081B RID: 2075 RVA: 0x00034334 File Offset: 0x00032534
		public HImage ConvertImageType(string newType)
		{
			IntPtr proc = HalconAPI.PreCall(1471);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, newType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert two real-valued images into a vector field image.
		///   Instance represents: Vector component in the row direction.
		/// </summary>
		/// <param name="col">Vector component in the column direction.</param>
		/// <param name="type">Semantic kind of the vector field. Default: "vector_field_relative"</param>
		/// <returns>Displacement vector field.</returns>
		// Token: 0x0600081C RID: 2076 RVA: 0x00034384 File Offset: 0x00032584
		public HImage RealToVectorField(HImage col, string type)
		{
			IntPtr proc = HalconAPI.PreCall(1472);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, col);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(col);
			return result;
		}

		/// <summary>
		///   Convert a vector field image into two real-valued images.
		///   Instance represents: Vector field.
		/// </summary>
		/// <param name="col">Vector component in the column direction.</param>
		/// <returns>Vector component in the row direction.</returns>
		// Token: 0x0600081D RID: 2077 RVA: 0x000343E4 File Offset: 0x000325E4
		public HImage VectorFieldToReal(out HImage col)
		{
			IntPtr proc = HalconAPI.PreCall(1473);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out col);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert two real images into a complex image.
		///   Instance represents: Real part.
		/// </summary>
		/// <param name="imageImaginary">Imaginary part.</param>
		/// <returns>Complex image.</returns>
		// Token: 0x0600081E RID: 2078 RVA: 0x00034440 File Offset: 0x00032640
		public HImage RealToComplex(HImage imageImaginary)
		{
			IntPtr proc = HalconAPI.PreCall(1474);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageImaginary);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageImaginary);
			return result;
		}

		/// <summary>
		///   Convert a complex image into two real images.
		///   Instance represents: Complex image.
		/// </summary>
		/// <param name="imageImaginary">Imaginary part.</param>
		/// <returns>Real part.</returns>
		// Token: 0x0600081F RID: 2079 RVA: 0x00034498 File Offset: 0x00032698
		public HImage ComplexToReal(out HImage imageImaginary)
		{
			IntPtr proc = HalconAPI.PreCall(1475);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageImaginary);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Paint regions with their average gray value.
		///   Instance represents: original gray-value image.
		/// </summary>
		/// <param name="regions">Input regions.</param>
		/// <returns>Result image with painted regions.</returns>
		// Token: 0x06000820 RID: 2080 RVA: 0x000344F4 File Offset: 0x000326F4
		public HImage RegionToMean(HRegion regions)
		{
			IntPtr proc = HalconAPI.PreCall(1476);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the lowest possible gray value on an arbitrary path to the image border for each point in the image.
		///   Instance represents: Image being processed.
		/// </summary>
		/// <returns>Result image.</returns>
		// Token: 0x06000821 RID: 2081 RVA: 0x0003454C File Offset: 0x0003274C
		public HImage GrayInside()
		{
			IntPtr proc = HalconAPI.PreCall(1477);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Symmetry of gray values along a row.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskSize">Extension of search area. Default: 40</param>
		/// <param name="direction">Angle of test direction. Default: 0.0</param>
		/// <param name="exponent">Exponent for weighting. Default: 0.5</param>
		/// <returns>Symmetry image.</returns>
		// Token: 0x06000822 RID: 2082 RVA: 0x00034594 File Offset: 0x00032794
		public HImage Symmetry(int maskSize, double direction, double exponent)
		{
			IntPtr proc = HalconAPI.PreCall(1478);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskSize);
			HalconAPI.StoreD(proc, 1, direction);
			HalconAPI.StoreD(proc, 2, exponent);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Selection of gray values of a multi-channel image using an index image.
		///   Instance represents: Multi-channel gray value image.
		/// </summary>
		/// <param name="indexImage">Image, where pixel values are interpreted as channel index.</param>
		/// <returns>Resulting image.</returns>
		// Token: 0x06000823 RID: 2083 RVA: 0x000345F4 File Offset: 0x000327F4
		public HImage SelectGrayvaluesFromChannels(HImage indexImage)
		{
			IntPtr proc = HalconAPI.PreCall(1479);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, indexImage);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(indexImage);
			return result;
		}

		/// <summary>
		///   Extract depth using multiple focus levels.
		///   Instance represents: Multichannel gray image consisting of multiple focus levels.
		/// </summary>
		/// <param name="confidence">Confidence of depth estimation.</param>
		/// <param name="filter">Filter used to find sharp pixels. Default: "highpass"</param>
		/// <param name="selection">Method used to find sharp pixels. Default: "next_maximum"</param>
		/// <returns>Depth image.</returns>
		// Token: 0x06000824 RID: 2084 RVA: 0x0003464C File Offset: 0x0003284C
		public HImage DepthFromFocus(out HImage confidence, HTuple filter, HTuple selection)
		{
			IntPtr proc = HalconAPI.PreCall(1480);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, filter);
			HalconAPI.Store(proc, 1, selection);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(filter);
			HalconAPI.UnpinTuple(selection);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract depth using multiple focus levels.
		///   Instance represents: Multichannel gray image consisting of multiple focus levels.
		/// </summary>
		/// <param name="confidence">Confidence of depth estimation.</param>
		/// <param name="filter">Filter used to find sharp pixels. Default: "highpass"</param>
		/// <param name="selection">Method used to find sharp pixels. Default: "next_maximum"</param>
		/// <returns>Depth image.</returns>
		// Token: 0x06000825 RID: 2085 RVA: 0x000346C4 File Offset: 0x000328C4
		public HImage DepthFromFocus(out HImage confidence, string filter, string selection)
		{
			IntPtr proc = HalconAPI.PreCall(1480);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreS(proc, 1, selection);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out confidence);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the uncalibrated scene flow between two stereo image pairs.
		///   Instance represents: Input image 1 at time @f$t_{1}$t_1.
		/// </summary>
		/// <param name="imageRect2T1">Input image 2 at time @f$t_{1}$t_1.</param>
		/// <param name="imageRect1T2">Input image 1 at time @f$t_{2}$t_2.</param>
		/// <param name="imageRect2T2">Input image 2 at time @f$t_{2}$t_2.</param>
		/// <param name="disparity">Disparity between input images 1 and 2 at time @f$t_{1}$t_1.</param>
		/// <param name="disparityChange">Estimated change in disparity.</param>
		/// <param name="smoothingFlow">Weight of the regularization term relative to the data term (derivatives of the optical flow). Default: 40.0</param>
		/// <param name="smoothingDisparity">Weight of the regularization term relative to the data term (derivatives of the disparity change). Default: 40.0</param>
		/// <param name="genParamName">Parameter name(s) for the algorithm. Default: "default_parameters"</param>
		/// <param name="genParamValue">Parameter value(s) for the algorithm. Default: "accurate"</param>
		/// <returns>Estimated optical flow.</returns>
		// Token: 0x06000826 RID: 2086 RVA: 0x00034730 File Offset: 0x00032930
		public HImage SceneFlowUncalib(HImage imageRect2T1, HImage imageRect1T2, HImage imageRect2T2, HImage disparity, out HImage disparityChange, HTuple smoothingFlow, HTuple smoothingDisparity, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1482);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2T1);
			HalconAPI.Store(proc, 3, imageRect1T2);
			HalconAPI.Store(proc, 4, imageRect2T2);
			HalconAPI.Store(proc, 5, disparity);
			HalconAPI.Store(proc, 0, smoothingFlow);
			HalconAPI.Store(proc, 1, smoothingDisparity);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(smoothingFlow);
			HalconAPI.UnpinTuple(smoothingDisparity);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out disparityChange);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2T1);
			GC.KeepAlive(imageRect1T2);
			GC.KeepAlive(imageRect2T2);
			GC.KeepAlive(disparity);
			return result;
		}

		/// <summary>
		///   Compute the uncalibrated scene flow between two stereo image pairs.
		///   Instance represents: Input image 1 at time @f$t_{1}$t_1.
		/// </summary>
		/// <param name="imageRect2T1">Input image 2 at time @f$t_{1}$t_1.</param>
		/// <param name="imageRect1T2">Input image 1 at time @f$t_{2}$t_2.</param>
		/// <param name="imageRect2T2">Input image 2 at time @f$t_{2}$t_2.</param>
		/// <param name="disparity">Disparity between input images 1 and 2 at time @f$t_{1}$t_1.</param>
		/// <param name="disparityChange">Estimated change in disparity.</param>
		/// <param name="smoothingFlow">Weight of the regularization term relative to the data term (derivatives of the optical flow). Default: 40.0</param>
		/// <param name="smoothingDisparity">Weight of the regularization term relative to the data term (derivatives of the disparity change). Default: 40.0</param>
		/// <param name="genParamName">Parameter name(s) for the algorithm. Default: "default_parameters"</param>
		/// <param name="genParamValue">Parameter value(s) for the algorithm. Default: "accurate"</param>
		/// <returns>Estimated optical flow.</returns>
		// Token: 0x06000827 RID: 2087 RVA: 0x00034808 File Offset: 0x00032A08
		public HImage SceneFlowUncalib(HImage imageRect2T1, HImage imageRect1T2, HImage imageRect2T2, HImage disparity, out HImage disparityChange, double smoothingFlow, double smoothingDisparity, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1482);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageRect2T1);
			HalconAPI.Store(proc, 3, imageRect1T2);
			HalconAPI.Store(proc, 4, imageRect2T2);
			HalconAPI.Store(proc, 5, disparity);
			HalconAPI.StoreD(proc, 0, smoothingFlow);
			HalconAPI.StoreD(proc, 1, smoothingDisparity);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreS(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out disparityChange);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageRect2T1);
			GC.KeepAlive(imageRect1T2);
			GC.KeepAlive(imageRect2T2);
			GC.KeepAlive(disparity);
			return result;
		}

		/// <summary>
		///   Unwarp an image using a vector field.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="vectorField">Input vector field.</param>
		/// <returns>Unwarped image.</returns>
		// Token: 0x06000828 RID: 2088 RVA: 0x000348C4 File Offset: 0x00032AC4
		public HImage UnwarpImageVectorField(HImage vectorField)
		{
			IntPtr proc = HalconAPI.PreCall(1483);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, vectorField);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(vectorField);
			return result;
		}

		/// <summary>
		///   Convolve a vector field with derivatives of the Gaussian.
		///   Instance represents: Input vector field.
		/// </summary>
		/// <param name="sigma">Sigma of the Gaussian. Default: 1.0</param>
		/// <param name="component">Component to be calculated. Default: "mean_curvature"</param>
		/// <returns>Filtered result images.</returns>
		// Token: 0x06000829 RID: 2089 RVA: 0x0003491C File Offset: 0x00032B1C
		public HImage DerivateVectorField(HTuple sigma, string component)
		{
			IntPtr proc = HalconAPI.PreCall(1484);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sigma);
			HalconAPI.StoreS(proc, 1, component);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigma);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convolve a vector field with derivatives of the Gaussian.
		///   Instance represents: Input vector field.
		/// </summary>
		/// <param name="sigma">Sigma of the Gaussian. Default: 1.0</param>
		/// <param name="component">Component to be calculated. Default: "mean_curvature"</param>
		/// <returns>Filtered result images.</returns>
		// Token: 0x0600082A RID: 2090 RVA: 0x0003497C File Offset: 0x00032B7C
		public HImage DerivateVectorField(double sigma, string component)
		{
			IntPtr proc = HalconAPI.PreCall(1484);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreS(proc, 1, component);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the length of the vectors of a vector field.
		///   Instance represents: Input vector field
		/// </summary>
		/// <param name="mode">Mode for computing the length of the vectors. Default: "length"</param>
		/// <returns>Length of the vectors of the vector field.</returns>
		// Token: 0x0600082B RID: 2091 RVA: 0x000349D4 File Offset: 0x00032BD4
		public HImage VectorFieldLength(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1485);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the optical flow between two images.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="imageT2">Input image 2.</param>
		/// <param name="algorithm">Algorithm for computing the optical flow. Default: "fdrig"</param>
		/// <param name="smoothingSigma">Standard deviation for initial Gaussian smoothing. Default: 0.8</param>
		/// <param name="integrationSigma">Standard deviation of the integration filter. Default: 1.0</param>
		/// <param name="flowSmoothness">Weight of the smoothing term relative to the data term. Default: 20.0</param>
		/// <param name="gradientConstancy">Weight of the gradient constancy relative to the gray value constancy. Default: 5.0</param>
		/// <param name="MGParamName">Parameter name(s) for the multigrid algorithm. Default: "default_parameters"</param>
		/// <param name="MGParamValue">Parameter value(s) for the multigrid algorithm. Default: "accurate"</param>
		/// <returns>Optical flow.</returns>
		// Token: 0x0600082C RID: 2092 RVA: 0x00034A24 File Offset: 0x00032C24
		public HImage OpticalFlowMg(HImage imageT2, string algorithm, double smoothingSigma, double integrationSigma, double flowSmoothness, double gradientConstancy, HTuple MGParamName, HTuple MGParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1486);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageT2);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreD(proc, 1, smoothingSigma);
			HalconAPI.StoreD(proc, 2, integrationSigma);
			HalconAPI.StoreD(proc, 3, flowSmoothness);
			HalconAPI.StoreD(proc, 4, gradientConstancy);
			HalconAPI.Store(proc, 5, MGParamName);
			HalconAPI.Store(proc, 6, MGParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(MGParamName);
			HalconAPI.UnpinTuple(MGParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageT2);
			return result;
		}

		/// <summary>
		///   Compute the optical flow between two images.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="imageT2">Input image 2.</param>
		/// <param name="algorithm">Algorithm for computing the optical flow. Default: "fdrig"</param>
		/// <param name="smoothingSigma">Standard deviation for initial Gaussian smoothing. Default: 0.8</param>
		/// <param name="integrationSigma">Standard deviation of the integration filter. Default: 1.0</param>
		/// <param name="flowSmoothness">Weight of the smoothing term relative to the data term. Default: 20.0</param>
		/// <param name="gradientConstancy">Weight of the gradient constancy relative to the gray value constancy. Default: 5.0</param>
		/// <param name="MGParamName">Parameter name(s) for the multigrid algorithm. Default: "default_parameters"</param>
		/// <param name="MGParamValue">Parameter value(s) for the multigrid algorithm. Default: "accurate"</param>
		/// <returns>Optical flow.</returns>
		// Token: 0x0600082D RID: 2093 RVA: 0x00034AC8 File Offset: 0x00032CC8
		public HImage OpticalFlowMg(HImage imageT2, string algorithm, double smoothingSigma, double integrationSigma, double flowSmoothness, double gradientConstancy, string MGParamName, string MGParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(1486);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageT2);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreD(proc, 1, smoothingSigma);
			HalconAPI.StoreD(proc, 2, integrationSigma);
			HalconAPI.StoreD(proc, 3, flowSmoothness);
			HalconAPI.StoreD(proc, 4, gradientConstancy);
			HalconAPI.StoreS(proc, 5, MGParamName);
			HalconAPI.StoreS(proc, 6, MGParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageT2);
			return result;
		}

		/// <summary>
		///   Matching a template and an image in a resolution pyramid.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imageTemplate">The domain of this image will be matched with Image.</param>
		/// <param name="mode">Desired matching criterion. Default: "dfd"</param>
		/// <param name="level">Startlevel in the resolution pyramid (highest resolution: Level 0). Default: 1</param>
		/// <param name="threshold">Threshold to determine the "region of interest". Default: 30</param>
		/// <returns>Result image and result region: values of the matching criterion within the determined "region of interest".</returns>
		// Token: 0x0600082E RID: 2094 RVA: 0x00034B5C File Offset: 0x00032D5C
		public HImage ExhaustiveMatchMg(HImage imageTemplate, string mode, int level, int threshold)
		{
			IntPtr proc = HalconAPI.PreCall(1487);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageTemplate);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, level);
			HalconAPI.StoreI(proc, 2, threshold);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageTemplate);
			return result;
		}

		/// <summary>
		///   Preparing a pattern for template matching with rotation.
		///   Instance represents: Input image whose domain will be processed for the pattern matching.
		/// </summary>
		/// <param name="numLevel">Maximal number of pyramid levels. Default: 4</param>
		/// <param name="angleStart">Smallest Rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtend">Maximum positive Extension of AngleStart. Default: 0.79</param>
		/// <param name="angleStep">Step rate (angle precision) of matching. Default: 0.0982</param>
		/// <param name="optimize">Kind of optimizing. Default: "sort"</param>
		/// <param name="grayValues">Kind of grayvalues. Default: "original"</param>
		/// <returns>Template number.</returns>
		// Token: 0x0600082F RID: 2095 RVA: 0x00034BCC File Offset: 0x00032DCC
		public HTemplate CreateTemplateRot(int numLevel, double angleStart, double angleExtend, double angleStep, string optimize, string grayValues)
		{
			IntPtr proc = HalconAPI.PreCall(1488);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevel);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtend);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, optimize);
			HalconAPI.StoreS(proc, 5, grayValues);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTemplate result;
			num = HTemplate.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Preparing a pattern for template matching.
		///   Instance represents: Input image whose domain will be processed for the pattern matching.
		/// </summary>
		/// <param name="firstError">Not yet in use. Default: 255</param>
		/// <param name="numLevel">Maximal number of pyramid levels. Default: 4</param>
		/// <param name="optimize">Kind of optimizing. Default: "sort"</param>
		/// <param name="grayValues">Kind of grayvalues. Default: "original"</param>
		/// <returns>Template number.</returns>
		// Token: 0x06000830 RID: 2096 RVA: 0x00034C48 File Offset: 0x00032E48
		public HTemplate CreateTemplate(int firstError, int numLevel, string optimize, string grayValues)
		{
			IntPtr proc = HalconAPI.PreCall(1489);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, firstError);
			HalconAPI.StoreI(proc, 1, numLevel);
			HalconAPI.StoreS(proc, 2, optimize);
			HalconAPI.StoreS(proc, 3, grayValues);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTemplate result;
			num = HTemplate.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Adapting a template to the size of an image.
		///   Instance represents: Image which determines the size of the later matching.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		// Token: 0x06000831 RID: 2097 RVA: 0x00034CB4 File Offset: 0x00032EB4
		public void AdaptTemplate(HTemplate templateID)
		{
			IntPtr proc = HalconAPI.PreCall(1498);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching all good gray value matches in a pyramid.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximal average difference of the grayvalues. Default: 30.0</param>
		/// <param name="numLevel">Number of levels in the pyramid. Default: 3</param>
		/// <returns>All points which have an error below a certain threshold.</returns>
		// Token: 0x06000832 RID: 2098 RVA: 0x00034CF8 File Offset: 0x00032EF8
		public HRegion FastMatchMg(HTemplate templateID, double maxError, HTuple numLevel)
		{
			IntPtr proc = HalconAPI.PreCall(1499);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.Store(proc, 2, numLevel);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevel);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
			return result;
		}

		/// <summary>
		///   Searching all good gray value matches in a pyramid.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximal average difference of the grayvalues. Default: 30.0</param>
		/// <param name="numLevel">Number of levels in the pyramid. Default: 3</param>
		/// <returns>All points which have an error below a certain threshold.</returns>
		// Token: 0x06000833 RID: 2099 RVA: 0x00034D64 File Offset: 0x00032F64
		public HRegion FastMatchMg(HTemplate templateID, double maxError, int numLevel)
		{
			IntPtr proc = HalconAPI.PreCall(1499);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.StoreI(proc, 2, numLevel);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
			return result;
		}

		/// <summary>
		///   Searching the best gray value matches in a pre generated pyramid.
		///   Instance represents: Image pyramid inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximal average difference of the grayvalues. Default: 30.0</param>
		/// <param name="subPixel">Exactness in subpixels in case of 'true'. Default: "false"</param>
		/// <param name="numLevels">Number of the used resolution levels. Default: 3</param>
		/// <param name="whichLevels">Resolution level up to which the method "best match" is used. Default: "original"</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="error">Average divergence of the grayvalues in the best match.</param>
		// Token: 0x06000834 RID: 2100 RVA: 0x00034DCC File Offset: 0x00032FCC
		public void BestMatchPreMg(HTemplate templateID, double maxError, string subPixel, int numLevels, HTuple whichLevels, out double row, out double column, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(1500);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.StoreS(proc, 2, subPixel);
			HalconAPI.StoreI(proc, 3, numLevels);
			HalconAPI.Store(proc, 4, whichLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(whichLevels);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best gray value matches in a pre generated pyramid.
		///   Instance represents: Image pyramid inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximal average difference of the grayvalues. Default: 30.0</param>
		/// <param name="subPixel">Exactness in subpixels in case of 'true'. Default: "false"</param>
		/// <param name="numLevels">Number of the used resolution levels. Default: 3</param>
		/// <param name="whichLevels">Resolution level up to which the method "best match" is used. Default: "original"</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="error">Average divergence of the grayvalues in the best match.</param>
		// Token: 0x06000835 RID: 2101 RVA: 0x00034E70 File Offset: 0x00033070
		public void BestMatchPreMg(HTemplate templateID, double maxError, string subPixel, int numLevels, int whichLevels, out double row, out double column, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(1500);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.StoreS(proc, 2, subPixel);
			HalconAPI.StoreI(proc, 3, numLevels);
			HalconAPI.StoreI(proc, 4, whichLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best gray value matches in a pyramid.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximal average difference of the grayvalues. Default: 30.0</param>
		/// <param name="subPixel">Exactness in subpixels in case of 'true'. Default: "false"</param>
		/// <param name="numLevels">Number of the used resolution levels. Default: 4</param>
		/// <param name="whichLevels">Resolution level up to which the method "best match" is used. Default: 2</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="error">Average divergence of the grayvalues in the best match.</param>
		// Token: 0x06000836 RID: 2102 RVA: 0x00034F10 File Offset: 0x00033110
		public void BestMatchMg(HTemplate templateID, double maxError, string subPixel, int numLevels, HTuple whichLevels, out double row, out double column, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(1501);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.StoreS(proc, 2, subPixel);
			HalconAPI.StoreI(proc, 3, numLevels);
			HalconAPI.Store(proc, 4, whichLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(whichLevels);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best gray value matches in a pyramid.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximal average difference of the grayvalues. Default: 30.0</param>
		/// <param name="subPixel">Exactness in subpixels in case of 'true'. Default: "false"</param>
		/// <param name="numLevels">Number of the used resolution levels. Default: 4</param>
		/// <param name="whichLevels">Resolution level up to which the method "best match" is used. Default: 2</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="error">Average divergence of the grayvalues in the best match.</param>
		// Token: 0x06000837 RID: 2103 RVA: 0x00034FB4 File Offset: 0x000331B4
		public void BestMatchMg(HTemplate templateID, double maxError, string subPixel, int numLevels, int whichLevels, out double row, out double column, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(1501);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.StoreS(proc, 2, subPixel);
			HalconAPI.StoreI(proc, 3, numLevels);
			HalconAPI.StoreI(proc, 4, whichLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching all good matches of a template and an image.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximal average difference of the grayvalues. Default: 20.0</param>
		/// <returns>All points whose error lies below a certain threshold.</returns>
		// Token: 0x06000838 RID: 2104 RVA: 0x00035054 File Offset: 0x00033254
		public HRegion FastMatch(HTemplate templateID, double maxError)
		{
			IntPtr proc = HalconAPI.PreCall(1502);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
			return result;
		}

		/// <summary>
		///   Searching the best matching of a template and a pyramid with rotation.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="angleStart">Smallest Rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtend">Maximum positive Extension of AngleStart. Default: 0.79</param>
		/// <param name="maxError">Maximum average difference of the grayvalues. Default: 40.0</param>
		/// <param name="subPixel">Subpixel accuracy in case of 'true'. Default: "false"</param>
		/// <param name="numLevels">Number of the used resolution levels. Default: 3</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="angle">Rotation angle of pattern.</param>
		/// <param name="error">Average divergence of the grayvalues of the best match.</param>
		// Token: 0x06000839 RID: 2105 RVA: 0x000350B4 File Offset: 0x000332B4
		public void BestMatchRotMg(HTemplate templateID, double angleStart, double angleExtend, double maxError, string subPixel, int numLevels, out HTuple row, out HTuple column, out HTuple angle, out HTuple error)
		{
			IntPtr proc = HalconAPI.PreCall(1503);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtend);
			HalconAPI.StoreD(proc, 3, maxError);
			HalconAPI.StoreS(proc, 4, subPixel);
			HalconAPI.StoreI(proc, 5, numLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best matching of a template and a pyramid with rotation.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="angleStart">Smallest Rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtend">Maximum positive Extension of AngleStart. Default: 0.79</param>
		/// <param name="maxError">Maximum average difference of the grayvalues. Default: 40.0</param>
		/// <param name="subPixel">Subpixel accuracy in case of 'true'. Default: "false"</param>
		/// <param name="numLevels">Number of the used resolution levels. Default: 3</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="angle">Rotation angle of pattern.</param>
		/// <param name="error">Average divergence of the grayvalues of the best match.</param>
		// Token: 0x0600083A RID: 2106 RVA: 0x00035174 File Offset: 0x00033374
		public void BestMatchRotMg(HTemplate templateID, double angleStart, double angleExtend, double maxError, string subPixel, int numLevels, out double row, out double column, out double angle, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(1503);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtend);
			HalconAPI.StoreD(proc, 3, maxError);
			HalconAPI.StoreS(proc, 4, subPixel);
			HalconAPI.StoreI(proc, 5, numLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out angle);
			num = HalconAPI.LoadD(proc, 3, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best matching of a template and an image with rotation.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="angleStart">Smallest Rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtend">Maximum positive Extension of AngleStart. Default: 0.79</param>
		/// <param name="maxError">Maximum average difference of the grayvalues. Default: 30.0</param>
		/// <param name="subPixel">Subpixel accuracy in case of 'true'. Default: "false"</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="angle">Rotation angle of pattern.</param>
		/// <param name="error">Average divergence of the grayvalues of the best match.</param>
		// Token: 0x0600083B RID: 2107 RVA: 0x00035230 File Offset: 0x00033430
		public void BestMatchRot(HTemplate templateID, double angleStart, double angleExtend, double maxError, string subPixel, out HTuple row, out HTuple column, out HTuple angle, out HTuple error)
		{
			IntPtr proc = HalconAPI.PreCall(1504);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtend);
			HalconAPI.StoreD(proc, 3, maxError);
			HalconAPI.StoreS(proc, 4, subPixel);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best matching of a template and an image with rotation.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="angleStart">Smallest Rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtend">Maximum positive Extension of AngleStart. Default: 0.79</param>
		/// <param name="maxError">Maximum average difference of the grayvalues. Default: 30.0</param>
		/// <param name="subPixel">Subpixel accuracy in case of 'true'. Default: "false"</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="angle">Rotation angle of pattern.</param>
		/// <param name="error">Average divergence of the grayvalues of the best match.</param>
		// Token: 0x0600083C RID: 2108 RVA: 0x000352E4 File Offset: 0x000334E4
		public void BestMatchRot(HTemplate templateID, double angleStart, double angleExtend, double maxError, string subPixel, out double row, out double column, out double angle, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(1504);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtend);
			HalconAPI.StoreD(proc, 3, maxError);
			HalconAPI.StoreS(proc, 4, subPixel);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out angle);
			num = HalconAPI.LoadD(proc, 3, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best matching of a template and an image.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximum average difference of the grayvalues. Default: 20.0</param>
		/// <param name="subPixel">Subpixel accuracy in case of 'true'. Default: "false"</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="error">Average divergence of the grayvalues of the best match.</param>
		// Token: 0x0600083D RID: 2109 RVA: 0x00035394 File Offset: 0x00033594
		public void BestMatch(HTemplate templateID, double maxError, string subPixel, out HTuple row, out HTuple column, out HTuple error)
		{
			IntPtr proc = HalconAPI.PreCall(1505);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.StoreS(proc, 2, subPixel);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Searching the best matching of a template and an image.
		///   Instance represents: Input image inside of which the pattern has to be found.
		/// </summary>
		/// <param name="templateID">Template number.</param>
		/// <param name="maxError">Maximum average difference of the grayvalues. Default: 20.0</param>
		/// <param name="subPixel">Subpixel accuracy in case of 'true'. Default: "false"</param>
		/// <param name="row">Row position of the best match.</param>
		/// <param name="column">Column position of the best match.</param>
		/// <param name="error">Average divergence of the grayvalues of the best match.</param>
		// Token: 0x0600083E RID: 2110 RVA: 0x00035424 File Offset: 0x00033624
		public void BestMatch(HTemplate templateID, double maxError, string subPixel, out double row, out double column, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(1505);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, templateID);
			HalconAPI.StoreD(proc, 1, maxError);
			HalconAPI.StoreS(proc, 2, subPixel);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(templateID);
		}

		/// <summary>
		///   Matching of a template and an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="regionOfInterest">Area to be searched in the input image.</param>
		/// <param name="imageTemplate">This area  will be "matched" by Image within the RegionOfInterest.</param>
		/// <param name="mode">Desired matching criterion. Default: "dfd"</param>
		/// <returns>Result image: values of the matching criterion.</returns>
		// Token: 0x0600083F RID: 2111 RVA: 0x000354B0 File Offset: 0x000336B0
		public HImage ExhaustiveMatch(HRegion regionOfInterest, HImage imageTemplate, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1506);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, regionOfInterest);
			HalconAPI.Store(proc, 3, imageTemplate);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regionOfInterest);
			GC.KeepAlive(imageTemplate);
			return result;
		}

		/// <summary>
		///   Searching corners in images.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="size">Desired filtersize of the graymask. Default: 3</param>
		/// <param name="weight">Weighting. Default: 0.04</param>
		/// <returns>Result of the filtering.</returns>
		// Token: 0x06000840 RID: 2112 RVA: 0x0003551C File Offset: 0x0003371C
		public HImage CornerResponse(int size, double weight)
		{
			IntPtr proc = HalconAPI.PreCall(1507);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, size);
			HalconAPI.StoreD(proc, 1, weight);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculating a Gauss pyramid.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="mode">Kind of filtermask. Default: "weighted"</param>
		/// <param name="scale">Factor for scaling down. Default: 0.5</param>
		/// <returns>Output images.</returns>
		// Token: 0x06000841 RID: 2113 RVA: 0x00035574 File Offset: 0x00033774
		public HImage GenGaussPyramid(string mode, double scale)
		{
			IntPtr proc = HalconAPI.PreCall(1508);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreD(proc, 1, scale);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculating the monotony operation.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Result of the monotony operator.</returns>
		// Token: 0x06000842 RID: 2114 RVA: 0x000355CC File Offset: 0x000337CC
		public HImage Monotony()
		{
			IntPtr proc = HalconAPI.PreCall(1509);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Edge extraction using bandpass filters.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="filterType">Filter type: currently only 'lines' is supported. Default: "lines"</param>
		/// <returns>Bandpass-filtered images.</returns>
		// Token: 0x06000843 RID: 2115 RVA: 0x00035614 File Offset: 0x00033814
		public HImage BandpassImage(string filterType)
		{
			IntPtr proc = HalconAPI.PreCall(1510);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect color lines and their width.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Amount of Gaussian smoothing to be applied. Default: 1.5</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 3</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 8</param>
		/// <param name="extractWidth">Should the line width be extracted? Default: "true"</param>
		/// <param name="completeJunctions">Should junctions be added where they cannot be extracted? Default: "true"</param>
		/// <returns>Extracted lines.</returns>
		// Token: 0x06000844 RID: 2116 RVA: 0x00035664 File Offset: 0x00033864
		public HXLDCont LinesColor(HTuple sigma, HTuple low, HTuple high, string extractWidth, string completeJunctions)
		{
			IntPtr proc = HalconAPI.PreCall(1511);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sigma);
			HalconAPI.Store(proc, 1, low);
			HalconAPI.Store(proc, 2, high);
			HalconAPI.StoreS(proc, 3, extractWidth);
			HalconAPI.StoreS(proc, 4, completeJunctions);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigma);
			HalconAPI.UnpinTuple(low);
			HalconAPI.UnpinTuple(high);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect color lines and their width.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Amount of Gaussian smoothing to be applied. Default: 1.5</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 3</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 8</param>
		/// <param name="extractWidth">Should the line width be extracted? Default: "true"</param>
		/// <param name="completeJunctions">Should junctions be added where they cannot be extracted? Default: "true"</param>
		/// <returns>Extracted lines.</returns>
		// Token: 0x06000845 RID: 2117 RVA: 0x000356E8 File Offset: 0x000338E8
		public HXLDCont LinesColor(double sigma, double low, double high, string extractWidth, string completeJunctions)
		{
			IntPtr proc = HalconAPI.PreCall(1511);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, low);
			HalconAPI.StoreD(proc, 2, high);
			HalconAPI.StoreS(proc, 3, extractWidth);
			HalconAPI.StoreS(proc, 4, completeJunctions);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect lines and their width.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Amount of Gaussian smoothing to be applied. Default: 1.5</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 3</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 8</param>
		/// <param name="lightDark">Extract bright or dark lines. Default: "light"</param>
		/// <param name="extractWidth">Should the line width be extracted? Default: "true"</param>
		/// <param name="lineModel">Line model used to correct the line position and width. Default: "bar-shaped"</param>
		/// <param name="completeJunctions">Should junctions be added where they cannot be extracted? Default: "true"</param>
		/// <returns>Extracted lines.</returns>
		// Token: 0x06000846 RID: 2118 RVA: 0x0003575C File Offset: 0x0003395C
		public HXLDCont LinesGauss(HTuple sigma, HTuple low, HTuple high, string lightDark, string extractWidth, string lineModel, string completeJunctions)
		{
			IntPtr proc = HalconAPI.PreCall(1512);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sigma);
			HalconAPI.Store(proc, 1, low);
			HalconAPI.Store(proc, 2, high);
			HalconAPI.StoreS(proc, 3, lightDark);
			HalconAPI.StoreS(proc, 4, extractWidth);
			HalconAPI.StoreS(proc, 5, lineModel);
			HalconAPI.StoreS(proc, 6, completeJunctions);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigma);
			HalconAPI.UnpinTuple(low);
			HalconAPI.UnpinTuple(high);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect lines and their width.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Amount of Gaussian smoothing to be applied. Default: 1.5</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 3</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 8</param>
		/// <param name="lightDark">Extract bright or dark lines. Default: "light"</param>
		/// <param name="extractWidth">Should the line width be extracted? Default: "true"</param>
		/// <param name="lineModel">Line model used to correct the line position and width. Default: "bar-shaped"</param>
		/// <param name="completeJunctions">Should junctions be added where they cannot be extracted? Default: "true"</param>
		/// <returns>Extracted lines.</returns>
		// Token: 0x06000847 RID: 2119 RVA: 0x000357F4 File Offset: 0x000339F4
		public HXLDCont LinesGauss(double sigma, double low, double high, string lightDark, string extractWidth, string lineModel, string completeJunctions)
		{
			IntPtr proc = HalconAPI.PreCall(1512);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, low);
			HalconAPI.StoreD(proc, 2, high);
			HalconAPI.StoreS(proc, 3, lightDark);
			HalconAPI.StoreS(proc, 4, extractWidth);
			HalconAPI.StoreS(proc, 5, lineModel);
			HalconAPI.StoreS(proc, 6, completeJunctions);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detection of lines using the facet model.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskSize">Size of the facet model mask. Default: 5</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 3</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 8</param>
		/// <param name="lightDark">Extract bright or dark lines. Default: "light"</param>
		/// <returns>Extracted lines.</returns>
		// Token: 0x06000848 RID: 2120 RVA: 0x00035878 File Offset: 0x00033A78
		public HXLDCont LinesFacet(int maskSize, HTuple low, HTuple high, string lightDark)
		{
			IntPtr proc = HalconAPI.PreCall(1513);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskSize);
			HalconAPI.Store(proc, 1, low);
			HalconAPI.Store(proc, 2, high);
			HalconAPI.StoreS(proc, 3, lightDark);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(low);
			HalconAPI.UnpinTuple(high);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detection of lines using the facet model.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="maskSize">Size of the facet model mask. Default: 5</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 3</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 8</param>
		/// <param name="lightDark">Extract bright or dark lines. Default: "light"</param>
		/// <returns>Extracted lines.</returns>
		// Token: 0x06000849 RID: 2121 RVA: 0x000358F0 File Offset: 0x00033AF0
		public HXLDCont LinesFacet(int maskSize, double low, double high, string lightDark)
		{
			IntPtr proc = HalconAPI.PreCall(1513);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskSize);
			HalconAPI.StoreD(proc, 1, low);
			HalconAPI.StoreD(proc, 2, high);
			HalconAPI.StoreS(proc, 3, lightDark);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Store a filter mask in the spatial domain as a real-image.
		///   Modified instance represents: Filter in the spatial domain.
		/// </summary>
		/// <param name="filterMask">Filter mask as file name or tuple. Default: "gauss"</param>
		/// <param name="scale">Scaling factor. Default: 1.0</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x0600084A RID: 2122 RVA: 0x0003595C File Offset: 0x00033B5C
		public void GenFilterMask(HTuple filterMask, double scale, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1514);
			HalconAPI.Store(proc, 0, filterMask);
			HalconAPI.StoreD(proc, 1, scale);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(filterMask);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Store a filter mask in the spatial domain as a real-image.
		///   Modified instance represents: Filter in the spatial domain.
		/// </summary>
		/// <param name="filterMask">Filter mask as file name or tuple. Default: "gauss"</param>
		/// <param name="scale">Scaling factor. Default: 1.0</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x0600084B RID: 2123 RVA: 0x000359C8 File Offset: 0x00033BC8
		public void GenFilterMask(string filterMask, double scale, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1514);
			HalconAPI.StoreS(proc, 0, filterMask);
			HalconAPI.StoreD(proc, 1, scale);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate a mean filter in the frequency domain.
		///   Modified instance represents: Mean filter as image in the frequency domain.
		/// </summary>
		/// <param name="maskShape">Shape of the filter mask in the spatial domain. Default: "ellipse"</param>
		/// <param name="diameter1">Diameter of the mean filter in the principal direction of the filter in the spatial domain. Default: 11.0</param>
		/// <param name="diameter2">Diameter of the mean filter perpendicular to the principal direction of the filter in the spatial domain. Default: 11.0</param>
		/// <param name="phi">Principal direction of the filter in the spatial domain. Default: 0.0</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x0600084C RID: 2124 RVA: 0x00035A30 File Offset: 0x00033C30
		public void GenMeanFilter(string maskShape, double diameter1, double diameter2, double phi, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1515);
			HalconAPI.StoreS(proc, 0, maskShape);
			HalconAPI.StoreD(proc, 1, diameter1);
			HalconAPI.StoreD(proc, 2, diameter2);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreS(proc, 4, norm);
			HalconAPI.StoreS(proc, 5, mode);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate a Gaussian filter in the frequency domain.
		///   Modified instance represents: Gaussian filter as image in the frequency domain.
		/// </summary>
		/// <param name="sigma1">Standard deviation of the Gaussian in the principal direction of the filter in the spatial domain. Default: 1.0</param>
		/// <param name="sigma2">Standard deviation of the Gaussian perpendicular to the principal direction of the filter in the spatial domain. Default: 1.0</param>
		/// <param name="phi">Principal direction of the filter in the spatial domain. Default: 0.0</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x0600084D RID: 2125 RVA: 0x00035ABC File Offset: 0x00033CBC
		public void GenGaussFilter(double sigma1, double sigma2, double phi, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1516);
			HalconAPI.StoreD(proc, 0, sigma1);
			HalconAPI.StoreD(proc, 1, sigma2);
			HalconAPI.StoreD(proc, 2, phi);
			HalconAPI.StoreS(proc, 3, norm);
			HalconAPI.StoreS(proc, 4, mode);
			HalconAPI.StoreI(proc, 5, width);
			HalconAPI.StoreI(proc, 6, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate a derivative filter in the frequency domain.
		///   Modified instance represents: Derivative filter as image in the frequency domain.
		/// </summary>
		/// <param name="derivative">Derivative to be computed. Default: "x"</param>
		/// <param name="exponent">Exponent used in the reverse transform. Default: 1</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x0600084E RID: 2126 RVA: 0x00035B3C File Offset: 0x00033D3C
		public void GenDerivativeFilter(string derivative, int exponent, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1517);
			HalconAPI.StoreS(proc, 0, derivative);
			HalconAPI.StoreI(proc, 1, exponent);
			HalconAPI.StoreS(proc, 2, norm);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate a bandpass filter with Gaussian or sinusoidal shape.
		///   Modified instance represents: Bandpass filter as image in the frequency domain.
		/// </summary>
		/// <param name="frequency">Distance of the filter's maximum from the DC term. Default: 0.1</param>
		/// <param name="sigma">Bandwidth of the filter (standard deviation). Default: 0.01</param>
		/// <param name="type">Filter type. Default: "sin"</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x0600084F RID: 2127 RVA: 0x00035BB4 File Offset: 0x00033DB4
		public void GenStdBandpass(double frequency, double sigma, string type, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1518);
			HalconAPI.StoreD(proc, 0, frequency);
			HalconAPI.StoreD(proc, 1, sigma);
			HalconAPI.StoreS(proc, 2, type);
			HalconAPI.StoreS(proc, 3, norm);
			HalconAPI.StoreS(proc, 4, mode);
			HalconAPI.StoreI(proc, 5, width);
			HalconAPI.StoreI(proc, 6, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate a bandpass filter with sinusoidal shape.
		///   Modified instance represents: Bandpass filter as image in the frequency domain.
		/// </summary>
		/// <param name="frequency">Distance of the filter's maximum from the DC term. Default: 0.1</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x06000850 RID: 2128 RVA: 0x00035C34 File Offset: 0x00033E34
		public void GenSinBandpass(double frequency, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1519);
			HalconAPI.StoreD(proc, 0, frequency);
			HalconAPI.StoreS(proc, 1, norm);
			HalconAPI.StoreS(proc, 2, mode);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate an ideal band filter.
		///   Modified instance represents: Band filter in the frequency domain.
		/// </summary>
		/// <param name="minFrequency">Minimum frequency. Default: 0.1</param>
		/// <param name="maxFrequency">Maximum frequency. Default: 0.2</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x06000851 RID: 2129 RVA: 0x00035CA4 File Offset: 0x00033EA4
		public void GenBandfilter(double minFrequency, double maxFrequency, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1520);
			HalconAPI.StoreD(proc, 0, minFrequency);
			HalconAPI.StoreD(proc, 1, maxFrequency);
			HalconAPI.StoreS(proc, 2, norm);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate an ideal bandpass filter.
		///   Modified instance represents: Bandpass filter in the frequency domain.
		/// </summary>
		/// <param name="minFrequency">Minimum frequency. Default: 0.1</param>
		/// <param name="maxFrequency">Maximum frequency. Default: 0.2</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x06000852 RID: 2130 RVA: 0x00035D1C File Offset: 0x00033F1C
		public void GenBandpass(double minFrequency, double maxFrequency, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1521);
			HalconAPI.StoreD(proc, 0, minFrequency);
			HalconAPI.StoreD(proc, 1, maxFrequency);
			HalconAPI.StoreS(proc, 2, norm);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate an ideal lowpass filter.
		///   Modified instance represents: Lowpass filter in the frequency domain.
		/// </summary>
		/// <param name="frequency">Cutoff frequency. Default: 0.1</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x06000853 RID: 2131 RVA: 0x00035D94 File Offset: 0x00033F94
		public void GenLowpass(double frequency, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1522);
			HalconAPI.StoreD(proc, 0, frequency);
			HalconAPI.StoreS(proc, 1, norm);
			HalconAPI.StoreS(proc, 2, mode);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate an ideal highpass filter.
		///   Modified instance represents: Highpass filter in the frequency domain.
		/// </summary>
		/// <param name="frequency">Cutoff frequency. Default: 0.1</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x06000854 RID: 2132 RVA: 0x00035E04 File Offset: 0x00034004
		public void GenHighpass(double frequency, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1523);
			HalconAPI.StoreD(proc, 0, frequency);
			HalconAPI.StoreS(proc, 1, norm);
			HalconAPI.StoreS(proc, 2, mode);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the power spectrum of a complex image.
		///   Instance represents: Input image in frequency domain.
		/// </summary>
		/// <returns>Power spectrum of the input image.</returns>
		// Token: 0x06000855 RID: 2133 RVA: 0x00035E74 File Offset: 0x00034074
		public HImage PowerLn()
		{
			IntPtr proc = HalconAPI.PreCall(1524);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the power spectrum of a complex image.
		///   Instance represents: Input image in frequency domain.
		/// </summary>
		/// <returns>Power spectrum of the input image.</returns>
		// Token: 0x06000856 RID: 2134 RVA: 0x00035EBC File Offset: 0x000340BC
		public HImage PowerReal()
		{
			IntPtr proc = HalconAPI.PreCall(1525);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the power spectrum of a complex image.
		///   Instance represents: Input image in frequency domain.
		/// </summary>
		/// <returns>Power spectrum of the input image.</returns>
		// Token: 0x06000857 RID: 2135 RVA: 0x00035F04 File Offset: 0x00034104
		public HImage PowerByte()
		{
			IntPtr proc = HalconAPI.PreCall(1526);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the phase of a complex image in degrees.
		///   Instance represents: Input image in frequency domain.
		/// </summary>
		/// <returns>Phase of the image in degrees.</returns>
		// Token: 0x06000858 RID: 2136 RVA: 0x00035F4C File Offset: 0x0003414C
		public HImage PhaseDeg()
		{
			IntPtr proc = HalconAPI.PreCall(1527);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the phase of a complex image in radians.
		///   Instance represents: Input image in frequency domain.
		/// </summary>
		/// <returns>Phase of the image in radians.</returns>
		// Token: 0x06000859 RID: 2137 RVA: 0x00035F94 File Offset: 0x00034194
		public HImage PhaseRad()
		{
			IntPtr proc = HalconAPI.PreCall(1528);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the energy of a two-channel image.
		///   Instance represents: 1st channel of input image (usually: Gabor image).
		/// </summary>
		/// <param name="imageHilbert">2nd channel of input image (usually: Hilbert image).</param>
		/// <returns>Image containing the local energy.</returns>
		// Token: 0x0600085A RID: 2138 RVA: 0x00035FDC File Offset: 0x000341DC
		public HImage EnergyGabor(HImage imageHilbert)
		{
			IntPtr proc = HalconAPI.PreCall(1529);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageHilbert);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageHilbert);
			return result;
		}

		/// <summary>
		///   Convolve an image with a Gabor filter in the frequency domain.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="gaborFilter">Gabor/Hilbert-Filter.</param>
		/// <param name="imageResultHilbert">Result of the Hilbert filter.</param>
		/// <returns>Result of the Gabor filter.</returns>
		// Token: 0x0600085B RID: 2139 RVA: 0x00036034 File Offset: 0x00034234
		public HImage ConvolGabor(HImage gaborFilter, out HImage imageResultHilbert)
		{
			IntPtr proc = HalconAPI.PreCall(1530);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, gaborFilter);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageResultHilbert);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(gaborFilter);
			return result;
		}

		/// <summary>
		///   Generate a Gabor filter.
		///   Modified instance represents: Gabor and Hilbert filter.
		/// </summary>
		/// <param name="angle">Angle range, inversely proportional to the range of orientations. Default: 1.4</param>
		/// <param name="frequency">Distance of the center of the filter to the DC term. Default: 0.4</param>
		/// <param name="bandwidth">Bandwidth range, inversely proportional to the range of frequencies being passed. Default: 1.0</param>
		/// <param name="orientation">Angle of the principal orientation. Default: 1.5</param>
		/// <param name="norm">Normalizing factor of the filter. Default: "none"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="width">Width of the image (filter). Default: 512</param>
		/// <param name="height">Height of the image (filter). Default: 512</param>
		// Token: 0x0600085C RID: 2140 RVA: 0x0003609C File Offset: 0x0003429C
		public void GenGabor(double angle, double frequency, double bandwidth, double orientation, string norm, string mode, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1531);
			HalconAPI.StoreD(proc, 0, angle);
			HalconAPI.StoreD(proc, 1, frequency);
			HalconAPI.StoreD(proc, 2, bandwidth);
			HalconAPI.StoreD(proc, 3, orientation);
			HalconAPI.StoreS(proc, 4, norm);
			HalconAPI.StoreS(proc, 5, mode);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the phase correlation of two images in the frequency domain.
		///   Instance represents: Fourier-transformed input image 1.
		/// </summary>
		/// <param name="imageFFT2">Fourier-transformed input image 2.</param>
		/// <returns>Phase correlation of the input images in the frequency domain.</returns>
		// Token: 0x0600085D RID: 2141 RVA: 0x00036128 File Offset: 0x00034328
		public HImage PhaseCorrelationFft(HImage imageFFT2)
		{
			IntPtr proc = HalconAPI.PreCall(1532);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageFFT2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageFFT2);
			return result;
		}

		/// <summary>
		///   Compute the correlation of two images in the frequency domain.
		///   Instance represents: Fourier-transformed input image 1.
		/// </summary>
		/// <param name="imageFFT2">Fourier-transformed input image 2.</param>
		/// <returns>Correlation of the input images in the frequency domain.</returns>
		// Token: 0x0600085E RID: 2142 RVA: 0x00036180 File Offset: 0x00034380
		public HImage CorrelationFft(HImage imageFFT2)
		{
			IntPtr proc = HalconAPI.PreCall(1533);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageFFT2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageFFT2);
			return result;
		}

		/// <summary>
		///   Convolve an image with a filter in the frequency domain.
		///   Instance represents: Complex input image.
		/// </summary>
		/// <param name="imageFilter">Filter in frequency domain.</param>
		/// <returns>Result of applying the filter.</returns>
		// Token: 0x0600085F RID: 2143 RVA: 0x000361D8 File Offset: 0x000343D8
		public HImage ConvolFft(HImage imageFilter)
		{
			IntPtr proc = HalconAPI.PreCall(1534);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageFilter);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageFilter);
			return result;
		}

		/// <summary>
		///   Compute the real-valued fast Fourier transform of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="direction">Calculate forward or reverse transform. Default: "to_freq"</param>
		/// <param name="norm">Normalizing factor of the transform. Default: "sqrt"</param>
		/// <param name="resultType">Image type of the output image. Default: "complex"</param>
		/// <param name="width">Width of the image for which the runtime should be optimized. Default: 512</param>
		/// <returns>Fourier-transformed image.</returns>
		// Token: 0x06000860 RID: 2144 RVA: 0x00036230 File Offset: 0x00034430
		public HImage RftGeneric(string direction, string norm, string resultType, int width)
		{
			IntPtr proc = HalconAPI.PreCall(1541);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, direction);
			HalconAPI.StoreS(proc, 1, norm);
			HalconAPI.StoreS(proc, 2, resultType);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the inverse fast Fourier transform of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Inverse-Fourier-transformed image.</returns>
		// Token: 0x06000861 RID: 2145 RVA: 0x0003629C File Offset: 0x0003449C
		public HImage FftImageInv()
		{
			IntPtr proc = HalconAPI.PreCall(1542);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fast Fourier transform of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Fourier-transformed image.</returns>
		// Token: 0x06000862 RID: 2146 RVA: 0x000362E4 File Offset: 0x000344E4
		public HImage FftImage()
		{
			IntPtr proc = HalconAPI.PreCall(1543);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fast Fourier transform of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="direction">Calculate forward or reverse transform. Default: "to_freq"</param>
		/// <param name="exponent">Sign of the exponent. Default: -1</param>
		/// <param name="norm">Normalizing factor of the transform. Default: "sqrt"</param>
		/// <param name="mode">Location of the DC term in the frequency domain. Default: "dc_center"</param>
		/// <param name="resultType">Image type of the output image. Default: "complex"</param>
		/// <returns>Fourier-transformed image.</returns>
		// Token: 0x06000863 RID: 2147 RVA: 0x0003632C File Offset: 0x0003452C
		public HImage FftGeneric(string direction, int exponent, string norm, string mode, string resultType)
		{
			IntPtr proc = HalconAPI.PreCall(1544);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, direction);
			HalconAPI.StoreI(proc, 1, exponent);
			HalconAPI.StoreS(proc, 2, norm);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.StoreS(proc, 4, resultType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply a shock filter to an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="theta">Time step. Default: 0.5</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <param name="mode">Type of edge detector. Default: "canny"</param>
		/// <param name="sigma">Smoothing of edge detector. Default: 1.0</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000864 RID: 2148 RVA: 0x000363A0 File Offset: 0x000345A0
		public HImage ShockFilter(double theta, int iterations, string mode, double sigma)
		{
			IntPtr proc = HalconAPI.PreCall(1545);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, theta);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreS(proc, 2, mode);
			HalconAPI.StoreD(proc, 3, sigma);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply the mean curvature flow to an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Smoothing parameter for derivative operator. Default: 0.5</param>
		/// <param name="theta">Time step. Default: 0.5</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000865 RID: 2149 RVA: 0x0003640C File Offset: 0x0003460C
		public HImage MeanCurvatureFlow(double sigma, double theta, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(1546);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, theta);
			HalconAPI.StoreI(proc, 2, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a coherence enhancing diffusion of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Smoothing for derivative operator. Default: 0.5</param>
		/// <param name="rho">Smoothing for diffusion coefficients. Default: 3.0</param>
		/// <param name="theta">Time step. Default: 0.5</param>
		/// <param name="iterations">Number of iterations. Default: 10</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000866 RID: 2150 RVA: 0x0003646C File Offset: 0x0003466C
		public HImage CoherenceEnhancingDiff(double sigma, double rho, double theta, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(1547);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, rho);
			HalconAPI.StoreD(proc, 2, theta);
			HalconAPI.StoreI(proc, 3, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Histogram linearization of images
		///   Instance represents: Image to be enhanced.
		/// </summary>
		/// <returns>Image with linearized gray values.</returns>
		// Token: 0x06000867 RID: 2151 RVA: 0x000364D8 File Offset: 0x000346D8
		public HImage EquHistoImage()
		{
			IntPtr proc = HalconAPI.PreCall(1548);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Illuminate image.
		///   Instance represents: Image to be enhanced.
		/// </summary>
		/// <param name="maskWidth">Width of low pass mask. Default: 101</param>
		/// <param name="maskHeight">Height of low pass mask. Default: 101</param>
		/// <param name="factor">Scales the "`correction gray value"' added to the original gray values. Default: 0.7</param>
		/// <returns>"`Illuminated"' image.</returns>
		// Token: 0x06000868 RID: 2152 RVA: 0x00036520 File Offset: 0x00034720
		public HImage Illuminate(int maskWidth, int maskHeight, double factor)
		{
			IntPtr proc = HalconAPI.PreCall(1549);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreD(proc, 2, factor);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Enhance contrast of the image.
		///   Instance represents: Image to be enhanced.
		/// </summary>
		/// <param name="maskWidth">Width of low pass mask. Default: 7</param>
		/// <param name="maskHeight">Height of the low pass mask. Default: 7</param>
		/// <param name="factor">Intensity of contrast emphasis. Default: 1.0</param>
		/// <returns>contrast enhanced image.</returns>
		// Token: 0x06000869 RID: 2153 RVA: 0x00036580 File Offset: 0x00034780
		public HImage Emphasize(int maskWidth, int maskHeight, double factor)
		{
			IntPtr proc = HalconAPI.PreCall(1550);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, maskWidth);
			HalconAPI.StoreI(proc, 1, maskHeight);
			HalconAPI.StoreD(proc, 2, factor);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Maximum gray value spreading in the value range 0 to 255.
		///   Instance represents: Image to be scaled.
		/// </summary>
		/// <returns>contrast enhanced image.</returns>
		// Token: 0x0600086A RID: 2154 RVA: 0x000365E0 File Offset: 0x000347E0
		public HImage ScaleImageMax()
		{
			IntPtr proc = HalconAPI.PreCall(1551);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude and direction) using the Robinson operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imageEdgeDir">Edge direction image.</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x0600086B RID: 2155 RVA: 0x00036628 File Offset: 0x00034828
		public HImage RobinsonDir(out HImage imageEdgeDir)
		{
			IntPtr proc = HalconAPI.PreCall(1552);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageEdgeDir);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude) using the Robinson operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x0600086C RID: 2156 RVA: 0x00036684 File Offset: 0x00034884
		public HImage RobinsonAmp()
		{
			IntPtr proc = HalconAPI.PreCall(1553);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude and direction) using the Kirsch operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imageEdgeDir">Edge direction image.</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x0600086D RID: 2157 RVA: 0x000366CC File Offset: 0x000348CC
		public HImage KirschDir(out HImage imageEdgeDir)
		{
			IntPtr proc = HalconAPI.PreCall(1554);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageEdgeDir);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude) using the Kirsch operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x0600086E RID: 2158 RVA: 0x00036728 File Offset: 0x00034928
		public HImage KirschAmp()
		{
			IntPtr proc = HalconAPI.PreCall(1555);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude and direction) using the Frei-Chen operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imageEdgeDir">Edge direction image.</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x0600086F RID: 2159 RVA: 0x00036770 File Offset: 0x00034970
		public HImage FreiDir(out HImage imageEdgeDir)
		{
			IntPtr proc = HalconAPI.PreCall(1556);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageEdgeDir);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude) using the Frei-Chen operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000870 RID: 2160 RVA: 0x000367CC File Offset: 0x000349CC
		public HImage FreiAmp()
		{
			IntPtr proc = HalconAPI.PreCall(1557);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude and direction) using the Prewitt operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imageEdgeDir">Edge direction image.</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000871 RID: 2161 RVA: 0x00036814 File Offset: 0x00034A14
		public HImage PrewittDir(out HImage imageEdgeDir)
		{
			IntPtr proc = HalconAPI.PreCall(1558);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageEdgeDir);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude) using the Prewitt operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000872 RID: 2162 RVA: 0x00036870 File Offset: 0x00034A70
		public HImage PrewittAmp()
		{
			IntPtr proc = HalconAPI.PreCall(1559);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude) using the Sobel operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filterType">Filter type. Default: "sum_abs"</param>
		/// <param name="size">Size of filter mask. Default: 3</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000873 RID: 2163 RVA: 0x000368B8 File Offset: 0x00034AB8
		public HImage SobelAmp(string filterType, HTuple size)
		{
			IntPtr proc = HalconAPI.PreCall(1560);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterType);
			HalconAPI.Store(proc, 1, size);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(size);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude) using the Sobel operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filterType">Filter type. Default: "sum_abs"</param>
		/// <param name="size">Size of filter mask. Default: 3</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000874 RID: 2164 RVA: 0x00036918 File Offset: 0x00034B18
		public HImage SobelAmp(string filterType, int size)
		{
			IntPtr proc = HalconAPI.PreCall(1560);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterType);
			HalconAPI.StoreI(proc, 1, size);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude and direction) using the Sobel operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="edgeDirection">Edge direction image.</param>
		/// <param name="filterType">Filter type. Default: "sum_abs"</param>
		/// <param name="size">Size of filter mask. Default: 3</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000875 RID: 2165 RVA: 0x00036970 File Offset: 0x00034B70
		public HImage SobelDir(out HImage edgeDirection, string filterType, HTuple size)
		{
			IntPtr proc = HalconAPI.PreCall(1561);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterType);
			HalconAPI.Store(proc, 1, size);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(size);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out edgeDirection);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges (amplitude and direction) using the Sobel operator.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="edgeDirection">Edge direction image.</param>
		/// <param name="filterType">Filter type. Default: "sum_abs"</param>
		/// <param name="size">Size of filter mask. Default: 3</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000876 RID: 2166 RVA: 0x000369E0 File Offset: 0x00034BE0
		public HImage SobelDir(out HImage edgeDirection, string filterType, int size)
		{
			IntPtr proc = HalconAPI.PreCall(1561);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterType);
			HalconAPI.StoreI(proc, 1, size);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out edgeDirection);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect edges using the Roberts filter.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filterType">Filter type. Default: "gradient_sum"</param>
		/// <returns>Roberts-filtered result images.</returns>
		// Token: 0x06000877 RID: 2167 RVA: 0x00036A4C File Offset: 0x00034C4C
		public HImage Roberts(string filterType)
		{
			IntPtr proc = HalconAPI.PreCall(1562);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filterType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the Laplace operator by using finite differences.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="resultType">Type of the result image, whereas for byte and uint2 the absolute value is used. Default: "absolute"</param>
		/// <param name="maskSize">Size of filter mask. Default: 3</param>
		/// <param name="filterMask">Filter mask used in the Laplace operator Default: "n_4"</param>
		/// <returns>Laplace-filtered result image.</returns>
		// Token: 0x06000878 RID: 2168 RVA: 0x00036A9C File Offset: 0x00034C9C
		public HImage Laplace(string resultType, HTuple maskSize, string filterMask)
		{
			IntPtr proc = HalconAPI.PreCall(1563);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, resultType);
			HalconAPI.Store(proc, 1, maskSize);
			HalconAPI.StoreS(proc, 2, filterMask);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(maskSize);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the Laplace operator by using finite differences.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="resultType">Type of the result image, whereas for byte and uint2 the absolute value is used. Default: "absolute"</param>
		/// <param name="maskSize">Size of filter mask. Default: 3</param>
		/// <param name="filterMask">Filter mask used in the Laplace operator Default: "n_4"</param>
		/// <returns>Laplace-filtered result image.</returns>
		// Token: 0x06000879 RID: 2169 RVA: 0x00036B04 File Offset: 0x00034D04
		public HImage Laplace(string resultType, int maskSize, string filterMask)
		{
			IntPtr proc = HalconAPI.PreCall(1563);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, resultType);
			HalconAPI.StoreI(proc, 1, maskSize);
			HalconAPI.StoreS(proc, 2, filterMask);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract high frequency components from an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="width">Width of the filter mask. Default: 9</param>
		/// <param name="height">Height of the filter mask. Default: 9</param>
		/// <returns>High-pass-filtered result image.</returns>
		// Token: 0x0600087A RID: 2170 RVA: 0x00036B64 File Offset: 0x00034D64
		public HImage HighpassImage(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1564);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract subpixel precise color edges using Deriche, Shen, or Canny filters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Edge operator to be applied. Default: "canny"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 1.0</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 20</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 40</param>
		/// <returns>Extracted edges.</returns>
		// Token: 0x0600087B RID: 2171 RVA: 0x00036BBC File Offset: 0x00034DBC
		public HXLDCont EdgesColorSubPix(string filter, double alpha, HTuple low, HTuple high)
		{
			IntPtr proc = HalconAPI.PreCall(1566);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.Store(proc, 2, low);
			HalconAPI.Store(proc, 3, high);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(low);
			HalconAPI.UnpinTuple(high);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract subpixel precise color edges using Deriche, Shen, or Canny filters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Edge operator to be applied. Default: "canny"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 1.0</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 20</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 40</param>
		/// <returns>Extracted edges.</returns>
		// Token: 0x0600087C RID: 2172 RVA: 0x00036C34 File Offset: 0x00034E34
		public HXLDCont EdgesColorSubPix(string filter, double alpha, double low, double high)
		{
			IntPtr proc = HalconAPI.PreCall(1566);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.StoreD(proc, 2, low);
			HalconAPI.StoreD(proc, 3, high);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract color edges using Canny, Deriche, or Shen filters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imaDir">Edge direction image.</param>
		/// <param name="filter">Edge operator to be applied. Default: "canny"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 1.0</param>
		/// <param name="NMS">Non-maximum suppression ('none', if not desired). Default: "nms"</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation (negative if no thresholding is desired). Default: 20</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation (negative if no thresholding is desired). Default: 40</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x0600087D RID: 2173 RVA: 0x00036CA0 File Offset: 0x00034EA0
		public HImage EdgesColor(out HImage imaDir, string filter, double alpha, string NMS, int low, int high)
		{
			IntPtr proc = HalconAPI.PreCall(1567);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.StoreS(proc, 2, NMS);
			HalconAPI.StoreI(proc, 3, low);
			HalconAPI.StoreI(proc, 4, high);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imaDir);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract sub-pixel precise edges using Deriche, Lanser, Shen, or Canny filters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Edge operator to be applied. Default: "canny"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 1.0</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 20</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 40</param>
		/// <returns>Extracted edges.</returns>
		// Token: 0x0600087E RID: 2174 RVA: 0x00036D28 File Offset: 0x00034F28
		public HXLDCont EdgesSubPix(string filter, double alpha, HTuple low, HTuple high)
		{
			IntPtr proc = HalconAPI.PreCall(1568);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.Store(proc, 2, low);
			HalconAPI.Store(proc, 3, high);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(low);
			HalconAPI.UnpinTuple(high);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract sub-pixel precise edges using Deriche, Lanser, Shen, or Canny filters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="filter">Edge operator to be applied. Default: "canny"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 1.0</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation. Default: 20</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation. Default: 40</param>
		/// <returns>Extracted edges.</returns>
		// Token: 0x0600087F RID: 2175 RVA: 0x00036DA0 File Offset: 0x00034FA0
		public HXLDCont EdgesSubPix(string filter, double alpha, int low, int high)
		{
			IntPtr proc = HalconAPI.PreCall(1568);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.StoreI(proc, 2, low);
			HalconAPI.StoreI(proc, 3, high);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract edges using Deriche, Lanser, Shen, or Canny filters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imaDir">Edge direction image.</param>
		/// <param name="filter">Edge operator to be applied. Default: "canny"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 1.0</param>
		/// <param name="NMS">Non-maximum suppression ('none', if not desired). Default: "nms"</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation (negative, if no thresholding is desired). Default: 20</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation (negative, if no thresholding is desired). Default: 40</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000880 RID: 2176 RVA: 0x00036E0C File Offset: 0x0003500C
		public HImage EdgesImage(out HImage imaDir, string filter, double alpha, string NMS, HTuple low, HTuple high)
		{
			IntPtr proc = HalconAPI.PreCall(1569);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.StoreS(proc, 2, NMS);
			HalconAPI.Store(proc, 3, low);
			HalconAPI.Store(proc, 4, high);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(low);
			HalconAPI.UnpinTuple(high);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imaDir);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract edges using Deriche, Lanser, Shen, or Canny filters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imaDir">Edge direction image.</param>
		/// <param name="filter">Edge operator to be applied. Default: "canny"</param>
		/// <param name="alpha">Filter parameter: small values result in strong smoothing, and thus less detail (opposite for 'canny'). Default: 1.0</param>
		/// <param name="NMS">Non-maximum suppression ('none', if not desired). Default: "nms"</param>
		/// <param name="low">Lower threshold for the hysteresis threshold operation (negative, if no thresholding is desired). Default: 20</param>
		/// <param name="high">Upper threshold for the hysteresis threshold operation (negative, if no thresholding is desired). Default: 40</param>
		/// <returns>Edge amplitude (gradient magnitude) image.</returns>
		// Token: 0x06000881 RID: 2177 RVA: 0x00036EA0 File Offset: 0x000350A0
		public HImage EdgesImage(out HImage imaDir, string filter, double alpha, string NMS, int low, int high)
		{
			IntPtr proc = HalconAPI.PreCall(1569);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, filter);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.StoreS(proc, 2, NMS);
			HalconAPI.StoreI(proc, 3, low);
			HalconAPI.StoreI(proc, 4, high);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imaDir);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convolve an image with derivatives of the Gaussian.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="sigma">Sigma of the Gaussian. Default: 1.0</param>
		/// <param name="component">Derivative or feature to be calculated. Default: "x"</param>
		/// <returns>Filtered result images.</returns>
		// Token: 0x06000882 RID: 2178 RVA: 0x00036F28 File Offset: 0x00035128
		public HImage DerivateGauss(HTuple sigma, string component)
		{
			IntPtr proc = HalconAPI.PreCall(1570);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sigma);
			HalconAPI.StoreS(proc, 1, component);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigma);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convolve an image with derivatives of the Gaussian.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="sigma">Sigma of the Gaussian. Default: 1.0</param>
		/// <param name="component">Derivative or feature to be calculated. Default: "x"</param>
		/// <returns>Filtered result images.</returns>
		// Token: 0x06000883 RID: 2179 RVA: 0x00036F88 File Offset: 0x00035188
		public HImage DerivateGauss(double sigma, string component)
		{
			IntPtr proc = HalconAPI.PreCall(1570);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreS(proc, 1, component);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   LoG-Operator (Laplace of Gaussian).
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Smoothing parameter of the Gaussian. Default: 2.0</param>
		/// <returns>Laplace filtered image.</returns>
		// Token: 0x06000884 RID: 2180 RVA: 0x00036FE0 File Offset: 0x000351E0
		public HImage LaplaceOfGauss(HTuple sigma)
		{
			IntPtr proc = HalconAPI.PreCall(1571);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, sigma);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sigma);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   LoG-Operator (Laplace of Gaussian).
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sigma">Smoothing parameter of the Gaussian. Default: 2.0</param>
		/// <returns>Laplace filtered image.</returns>
		// Token: 0x06000885 RID: 2181 RVA: 0x00037038 File Offset: 0x00035238
		public HImage LaplaceOfGauss(double sigma)
		{
			IntPtr proc = HalconAPI.PreCall(1571);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Approximate the LoG operator (Laplace of Gaussian).
		///   Instance represents: Input image
		/// </summary>
		/// <param name="sigma">Smoothing parameter of the Laplace operator to approximate. Default: 3.0</param>
		/// <param name="sigFactor">Ratio of the standard deviations used (Marr recommends 1.6). Default: 1.6</param>
		/// <returns>LoG image.</returns>
		// Token: 0x06000886 RID: 2182 RVA: 0x00037088 File Offset: 0x00035288
		public HImage DiffOfGauss(double sigma, double sigFactor)
		{
			IntPtr proc = HalconAPI.PreCall(1572);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, sigma);
			HalconAPI.StoreD(proc, 1, sigFactor);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detect straight edge segments.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="sobelSize">Mask size of the Sobel operator. Default: 5</param>
		/// <param name="minAmplitude">Minimum edge strength. Default: 32</param>
		/// <param name="maxDistance">Maximum distance of the approximating line to its original edge. Default: 3</param>
		/// <param name="minLength">Minimum length of to resulting line segments. Default: 10</param>
		/// <param name="beginRow">Row coordinate of the line segments' start points.</param>
		/// <param name="beginCol">Column coordinate of the line segments' start points.</param>
		/// <param name="endRow">Row coordinate of the line segments' end points.</param>
		/// <param name="endCol">Column coordinate of the line segments' end points.</param>
		// Token: 0x06000887 RID: 2183 RVA: 0x000370E0 File Offset: 0x000352E0
		public void DetectEdgeSegments(int sobelSize, int minAmplitude, int maxDistance, int minLength, out HTuple beginRow, out HTuple beginCol, out HTuple endRow, out HTuple endCol)
		{
			IntPtr proc = HalconAPI.PreCall(1575);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, sobelSize);
			HalconAPI.StoreI(proc, 1, minAmplitude);
			HalconAPI.StoreI(proc, 2, maxDistance);
			HalconAPI.StoreI(proc, 3, minLength);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out beginRow);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out beginCol);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out endRow);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out endCol);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>Release the look-up-table needed for color space transformation.</summary>
		/// <param name="colorTransLUTHandle">Handle of the look-up-table handle for the color space transformation.</param>
		// Token: 0x06000888 RID: 2184 RVA: 0x00037188 File Offset: 0x00035388
		public static void ClearColorTransLut(HColorTransLUT colorTransLUTHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1577);
			HalconAPI.Store(proc, 0, colorTransLUTHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(colorTransLUTHandle);
		}

		/// <summary>
		///   Color space transformation using pre-generated look-up-table.
		///   Instance represents: Input image (channel 1).
		/// </summary>
		/// <param name="image2">Input image (channel 2).</param>
		/// <param name="image3">Input image (channel 3).</param>
		/// <param name="imageResult2">Color-transformed output image (channel 2).</param>
		/// <param name="imageResult3">Color-transformed output image (channel 3).</param>
		/// <param name="colorTransLUTHandle">Handle of the look-up-table for the color space transformation.</param>
		/// <returns>Color-transformed output image (channel 1).</returns>
		// Token: 0x06000889 RID: 2185 RVA: 0x000371BC File Offset: 0x000353BC
		public HImage ApplyColorTransLut(HImage image2, HImage image3, out HImage imageResult2, out HImage imageResult3, HColorTransLUT colorTransLUTHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1578);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 3, image3);
			HalconAPI.Store(proc, 0, colorTransLUTHandle);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageResult2);
			num = HImage.LoadNew(proc, 3, num, out imageResult3);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			GC.KeepAlive(image3);
			GC.KeepAlive(colorTransLUTHandle);
			return result;
		}

		/// <summary>Creates the look-up-table for transformation of an image from the RGB color space to an arbitrary color space.</summary>
		/// <param name="colorSpace">Color space of the output image. Default: "hsv"</param>
		/// <param name="transDirection">Direction of color space transformation. Default: "from_rgb"</param>
		/// <param name="numBits">Number of bits of the input image. Default: 8</param>
		/// <returns>Handle of the look-up-table for color space transformation.</returns>
		// Token: 0x0600088A RID: 2186 RVA: 0x00037258 File Offset: 0x00035458
		public static HColorTransLUT CreateColorTransLut(string colorSpace, string transDirection, int numBits)
		{
			IntPtr proc = HalconAPI.PreCall(1579);
			HalconAPI.StoreS(proc, 0, colorSpace);
			HalconAPI.StoreS(proc, 1, transDirection);
			HalconAPI.StoreI(proc, 2, numBits);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HColorTransLUT result;
			num = HColorTransLUT.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>
		///   Convert a single-channel color filter array image into an RGB image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="CFAType">Color filter array type. Default: "bayer_gb"</param>
		/// <param name="interpolation">Interpolation type. Default: "bilinear"</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600088B RID: 2187 RVA: 0x000372A8 File Offset: 0x000354A8
		public HImage CfaToRgb(string CFAType, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1580);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, CFAType);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an RGB image into a gray scale image.
		///   Instance represents: Three-channel RBG image.
		/// </summary>
		/// <returns>Gray scale image.</returns>
		// Token: 0x0600088C RID: 2188 RVA: 0x00037300 File Offset: 0x00035500
		public HImage Rgb1ToGray()
		{
			IntPtr proc = HalconAPI.PreCall(1581);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an RGB image to a gray scale image.
		///   Instance represents: Input image (red channel).
		/// </summary>
		/// <param name="imageGreen">Input image (green channel).</param>
		/// <param name="imageBlue">Input image (blue channel).</param>
		/// <returns>Gray scale image.</returns>
		// Token: 0x0600088D RID: 2189 RVA: 0x00037348 File Offset: 0x00035548
		public HImage Rgb3ToGray(HImage imageGreen, HImage imageBlue)
		{
			IntPtr proc = HalconAPI.PreCall(1582);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageGreen);
			HalconAPI.Store(proc, 3, imageBlue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageGreen);
			GC.KeepAlive(imageBlue);
			return result;
		}

		/// <summary>
		///   Transform an image from the RGB color space to an arbitrary color space.
		///   Instance represents: Input image (red channel).
		/// </summary>
		/// <param name="imageGreen">Input image (green channel).</param>
		/// <param name="imageBlue">Input image (blue channel).</param>
		/// <param name="imageResult2">Color-transformed output image (channel 1).</param>
		/// <param name="imageResult3">Color-transformed output image (channel 1).</param>
		/// <param name="colorSpace">Color space of the output image. Default: "hsv"</param>
		/// <returns>Color-transformed output image (channel 1).</returns>
		// Token: 0x0600088E RID: 2190 RVA: 0x000373AC File Offset: 0x000355AC
		public HImage TransFromRgb(HImage imageGreen, HImage imageBlue, out HImage imageResult2, out HImage imageResult3, string colorSpace)
		{
			IntPtr proc = HalconAPI.PreCall(1583);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageGreen);
			HalconAPI.Store(proc, 3, imageBlue);
			HalconAPI.StoreS(proc, 0, colorSpace);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageResult2);
			num = HImage.LoadNew(proc, 3, num, out imageResult3);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageGreen);
			GC.KeepAlive(imageBlue);
			return result;
		}

		/// <summary>
		///   Transform an image from an arbitrary color space to the RGB color space.
		///   Instance represents: Input image (channel 1).
		/// </summary>
		/// <param name="imageInput2">Input image (channel 2).</param>
		/// <param name="imageInput3">Input image (channel 3).</param>
		/// <param name="imageGreen">Green channel.</param>
		/// <param name="imageBlue">Blue channel.</param>
		/// <param name="colorSpace">Color space of the input image. Default: "hsv"</param>
		/// <returns>Red channel.</returns>
		// Token: 0x0600088F RID: 2191 RVA: 0x00037440 File Offset: 0x00035640
		public HImage TransToRgb(HImage imageInput2, HImage imageInput3, out HImage imageGreen, out HImage imageBlue, string colorSpace)
		{
			IntPtr proc = HalconAPI.PreCall(1584);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageInput2);
			HalconAPI.Store(proc, 3, imageInput3);
			HalconAPI.StoreS(proc, 0, colorSpace);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out imageGreen);
			num = HImage.LoadNew(proc, 3, num, out imageBlue);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageInput2);
			GC.KeepAlive(imageInput3);
			return result;
		}

		/// <summary>
		///   Logical "AND" of each pixel using a bit mask.
		///   Instance represents: Input image(s).
		/// </summary>
		/// <param name="bitMask">Bit field Default: 128</param>
		/// <returns>Result image(s) by combination with mask.</returns>
		// Token: 0x06000890 RID: 2192 RVA: 0x000374D4 File Offset: 0x000356D4
		public HImage BitMask(int bitMask)
		{
			IntPtr proc = HalconAPI.PreCall(1585);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, bitMask);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Extract a bit from the pixels.
		///   Instance represents: Input image(s).
		/// </summary>
		/// <param name="bit">Bit to be selected. Default: 8</param>
		/// <returns>Result image(s) by extraction.</returns>
		// Token: 0x06000891 RID: 2193 RVA: 0x00037524 File Offset: 0x00035724
		public HImage BitSlice(int bit)
		{
			IntPtr proc = HalconAPI.PreCall(1586);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, bit);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Right shift of all pixels of the image.
		///   Instance represents: Input image(s).
		/// </summary>
		/// <param name="shift">shift value Default: 3</param>
		/// <returns>Result image(s) by shift operation.</returns>
		// Token: 0x06000892 RID: 2194 RVA: 0x00037574 File Offset: 0x00035774
		public HImage BitRshift(int shift)
		{
			IntPtr proc = HalconAPI.PreCall(1587);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, shift);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Left shift of all pixels of the image.
		///   Instance represents: Input image(s).
		/// </summary>
		/// <param name="shift">Shift value. Default: 3</param>
		/// <returns>Result image(s) by shift operation.</returns>
		// Token: 0x06000893 RID: 2195 RVA: 0x000375C4 File Offset: 0x000357C4
		public HImage BitLshift(int shift)
		{
			IntPtr proc = HalconAPI.PreCall(1588);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, shift);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Complement all bits of the pixels.
		///   Instance represents: Input image(s).
		/// </summary>
		/// <returns>Result image(s) by complement operation.</returns>
		// Token: 0x06000894 RID: 2196 RVA: 0x00037614 File Offset: 0x00035814
		public HImage BitNot()
		{
			IntPtr proc = HalconAPI.PreCall(1589);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Bit-by-bit XOR of all pixels of the input images.
		///   Instance represents: Input image(s) 1.
		/// </summary>
		/// <param name="image2">Input image(s) 2.</param>
		/// <returns>Result image(s) by XOR-operation.</returns>
		// Token: 0x06000895 RID: 2197 RVA: 0x0003765C File Offset: 0x0003585C
		public HImage BitXor(HImage image2)
		{
			IntPtr proc = HalconAPI.PreCall(1590);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Bit-by-bit OR of all pixels of the input images.
		///   Instance represents: Input image(s) 1.
		/// </summary>
		/// <param name="image2">Input image(s) 2.</param>
		/// <returns>Result image(s) by OR-operation.</returns>
		// Token: 0x06000896 RID: 2198 RVA: 0x000376B4 File Offset: 0x000358B4
		public HImage BitOr(HImage image2)
		{
			IntPtr proc = HalconAPI.PreCall(1591);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Bit-by-bit AND of all pixels of the input images.
		///   Instance represents: Input image(s) 1.
		/// </summary>
		/// <param name="image2">Input image(s) 2.</param>
		/// <returns>Result image(s) by AND-operation.</returns>
		// Token: 0x06000897 RID: 2199 RVA: 0x0003770C File Offset: 0x0003590C
		public HImage BitAnd(HImage image2)
		{
			IntPtr proc = HalconAPI.PreCall(1592);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Perform a gamma encoding or decoding of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="gamma">Gamma coefficient of the exponential part of the transformation. Default: 0.416666666667</param>
		/// <param name="offset">Offset of the exponential part of the transformation. Default: 0.055</param>
		/// <param name="threshold">Gray value for which the transformation switches from linear to exponential. Default: 0.0031308</param>
		/// <param name="maxGray">Maximum gray value of the input image type. Default: 255.0</param>
		/// <param name="encode">If 'true', perform a gamma encoding, otherwise a gamma decoding. Default: "true"</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000898 RID: 2200 RVA: 0x00037764 File Offset: 0x00035964
		public HImage GammaImage(double gamma, double offset, double threshold, HTuple maxGray, string encode)
		{
			IntPtr proc = HalconAPI.PreCall(1593);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, gamma);
			HalconAPI.StoreD(proc, 1, offset);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.Store(proc, 3, maxGray);
			HalconAPI.StoreS(proc, 4, encode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(maxGray);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a gamma encoding or decoding of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="gamma">Gamma coefficient of the exponential part of the transformation. Default: 0.416666666667</param>
		/// <param name="offset">Offset of the exponential part of the transformation. Default: 0.055</param>
		/// <param name="threshold">Gray value for which the transformation switches from linear to exponential. Default: 0.0031308</param>
		/// <param name="maxGray">Maximum gray value of the input image type. Default: 255.0</param>
		/// <param name="encode">If 'true', perform a gamma encoding, otherwise a gamma decoding. Default: "true"</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000899 RID: 2201 RVA: 0x000377E0 File Offset: 0x000359E0
		public HImage GammaImage(double gamma, double offset, double threshold, double maxGray, string encode)
		{
			IntPtr proc = HalconAPI.PreCall(1593);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, gamma);
			HalconAPI.StoreD(proc, 1, offset);
			HalconAPI.StoreD(proc, 2, threshold);
			HalconAPI.StoreD(proc, 3, maxGray);
			HalconAPI.StoreS(proc, 4, encode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Raise an image to a power.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="exponent">Power to which the gray values are raised. Default: 2</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600089A RID: 2202 RVA: 0x00037854 File Offset: 0x00035A54
		public HImage PowImage(HTuple exponent)
		{
			IntPtr proc = HalconAPI.PreCall(1594);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, exponent);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(exponent);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Raise an image to a power.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="exponent">Power to which the gray values are raised. Default: 2</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600089B RID: 2203 RVA: 0x000378AC File Offset: 0x00035AAC
		public HImage PowImage(double exponent)
		{
			IntPtr proc = HalconAPI.PreCall(1594);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, exponent);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the exponentiation of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="baseVal">Base of the exponentiation. Default: "e"</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600089C RID: 2204 RVA: 0x000378FC File Offset: 0x00035AFC
		public HImage ExpImage(HTuple baseVal)
		{
			IntPtr proc = HalconAPI.PreCall(1595);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, baseVal);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(baseVal);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the exponentiation of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="baseVal">Base of the exponentiation. Default: "e"</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600089D RID: 2205 RVA: 0x00037954 File Offset: 0x00035B54
		public HImage ExpImage(string baseVal)
		{
			IntPtr proc = HalconAPI.PreCall(1595);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, baseVal);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the logarithm of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="baseVal">Base of the logarithm. Default: "e"</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600089E RID: 2206 RVA: 0x000379A4 File Offset: 0x00035BA4
		public HImage LogImage(HTuple baseVal)
		{
			IntPtr proc = HalconAPI.PreCall(1596);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, baseVal);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(baseVal);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the logarithm of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="baseVal">Base of the logarithm. Default: "e"</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600089F RID: 2207 RVA: 0x000379FC File Offset: 0x00035BFC
		public HImage LogImage(string baseVal)
		{
			IntPtr proc = HalconAPI.PreCall(1596);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, baseVal);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the arctangent of two images.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="imageX">Input image 2.</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008A0 RID: 2208 RVA: 0x00037A4C File Offset: 0x00035C4C
		public HImage Atan2Image(HImage imageX)
		{
			IntPtr proc = HalconAPI.PreCall(1597);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageX);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageX);
			return result;
		}

		/// <summary>
		///   Calculate the arctangent of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Output image.</returns>
		// Token: 0x060008A1 RID: 2209 RVA: 0x00037AA4 File Offset: 0x00035CA4
		public HImage AtanImage()
		{
			IntPtr proc = HalconAPI.PreCall(1598);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the arccosine of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Output image.</returns>
		// Token: 0x060008A2 RID: 2210 RVA: 0x00037AEC File Offset: 0x00035CEC
		public HImage AcosImage()
		{
			IntPtr proc = HalconAPI.PreCall(1599);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the arcsine of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Output image.</returns>
		// Token: 0x060008A3 RID: 2211 RVA: 0x00037B34 File Offset: 0x00035D34
		public HImage AsinImage()
		{
			IntPtr proc = HalconAPI.PreCall(1600);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the tangent of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Output image.</returns>
		// Token: 0x060008A4 RID: 2212 RVA: 0x00037B7C File Offset: 0x00035D7C
		public HImage TanImage()
		{
			IntPtr proc = HalconAPI.PreCall(1601);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the cosine of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Output image.</returns>
		// Token: 0x060008A5 RID: 2213 RVA: 0x00037BC4 File Offset: 0x00035DC4
		public HImage CosImage()
		{
			IntPtr proc = HalconAPI.PreCall(1602);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the sine of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Output image.</returns>
		// Token: 0x060008A6 RID: 2214 RVA: 0x00037C0C File Offset: 0x00035E0C
		public HImage SinImage()
		{
			IntPtr proc = HalconAPI.PreCall(1603);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the absolute difference of two images.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="mult">Scale factor. Default: 1.0</param>
		/// <returns>Absolute value of the difference of the input images.</returns>
		// Token: 0x060008A7 RID: 2215 RVA: 0x00037C54 File Offset: 0x00035E54
		public HImage AbsDiffImage(HImage image2, HTuple mult)
		{
			IntPtr proc = HalconAPI.PreCall(1604);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, mult);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mult);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Calculate the absolute difference of two images.
		///   Instance represents: Input image 1.
		/// </summary>
		/// <param name="image2">Input image 2.</param>
		/// <param name="mult">Scale factor. Default: 1.0</param>
		/// <returns>Absolute value of the difference of the input images.</returns>
		// Token: 0x060008A8 RID: 2216 RVA: 0x00037CB8 File Offset: 0x00035EB8
		public HImage AbsDiffImage(HImage image2, double mult)
		{
			IntPtr proc = HalconAPI.PreCall(1604);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.StoreD(proc, 0, mult);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Calculate the square root of an image.
		///   Instance represents: Input image
		/// </summary>
		/// <returns>Output image</returns>
		// Token: 0x060008A9 RID: 2217 RVA: 0x00037D18 File Offset: 0x00035F18
		public HImage SqrtImage()
		{
			IntPtr proc = HalconAPI.PreCall(1605);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Subtract two images.
		///   Instance represents: Minuend(s).
		/// </summary>
		/// <param name="imageSubtrahend">Subtrahend(s).</param>
		/// <param name="mult">Correction factor. Default: 1.0</param>
		/// <param name="add">Correction value. Default: 128.0</param>
		/// <returns>Result image(s) by the subtraction.</returns>
		// Token: 0x060008AA RID: 2218 RVA: 0x00037D60 File Offset: 0x00035F60
		public HImage SubImage(HImage imageSubtrahend, HTuple mult, HTuple add)
		{
			IntPtr proc = HalconAPI.PreCall(1606);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageSubtrahend);
			HalconAPI.Store(proc, 0, mult);
			HalconAPI.Store(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mult);
			HalconAPI.UnpinTuple(add);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageSubtrahend);
			return result;
		}

		/// <summary>
		///   Subtract two images.
		///   Instance represents: Minuend(s).
		/// </summary>
		/// <param name="imageSubtrahend">Subtrahend(s).</param>
		/// <param name="mult">Correction factor. Default: 1.0</param>
		/// <param name="add">Correction value. Default: 128.0</param>
		/// <returns>Result image(s) by the subtraction.</returns>
		// Token: 0x060008AB RID: 2219 RVA: 0x00037DD4 File Offset: 0x00035FD4
		public HImage SubImage(HImage imageSubtrahend, double mult, double add)
		{
			IntPtr proc = HalconAPI.PreCall(1606);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageSubtrahend);
			HalconAPI.StoreD(proc, 0, mult);
			HalconAPI.StoreD(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageSubtrahend);
			return result;
		}

		/// <summary>
		///   Scale the gray values of an image.
		///   Instance represents: Image(s) whose gray values are to be scaled.
		/// </summary>
		/// <param name="mult">Scale factor. Default: 0.01</param>
		/// <param name="add">Offset. Default: 0</param>
		/// <returns>Result image(s) by the scale.</returns>
		// Token: 0x060008AC RID: 2220 RVA: 0x00037E3C File Offset: 0x0003603C
		public HImage ScaleImage(HTuple mult, HTuple add)
		{
			IntPtr proc = HalconAPI.PreCall(1607);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, mult);
			HalconAPI.Store(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mult);
			HalconAPI.UnpinTuple(add);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Scale the gray values of an image.
		///   Instance represents: Image(s) whose gray values are to be scaled.
		/// </summary>
		/// <param name="mult">Scale factor. Default: 0.01</param>
		/// <param name="add">Offset. Default: 0</param>
		/// <returns>Result image(s) by the scale.</returns>
		// Token: 0x060008AD RID: 2221 RVA: 0x00037EA0 File Offset: 0x000360A0
		public HImage ScaleImage(double mult, double add)
		{
			IntPtr proc = HalconAPI.PreCall(1607);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, mult);
			HalconAPI.StoreD(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Divide two images.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <param name="mult">Factor for gray range adaption. Default: 255</param>
		/// <param name="add">Value for gray range adaption. Default: 0</param>
		/// <returns>Result image(s) by the division.</returns>
		// Token: 0x060008AE RID: 2222 RVA: 0x00037EF8 File Offset: 0x000360F8
		public HImage DivImage(HImage image2, HTuple mult, HTuple add)
		{
			IntPtr proc = HalconAPI.PreCall(1608);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, mult);
			HalconAPI.Store(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mult);
			HalconAPI.UnpinTuple(add);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Divide two images.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <param name="mult">Factor for gray range adaption. Default: 255</param>
		/// <param name="add">Value for gray range adaption. Default: 0</param>
		/// <returns>Result image(s) by the division.</returns>
		// Token: 0x060008AF RID: 2223 RVA: 0x00037F6C File Offset: 0x0003616C
		public HImage DivImage(HImage image2, double mult, double add)
		{
			IntPtr proc = HalconAPI.PreCall(1608);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.StoreD(proc, 0, mult);
			HalconAPI.StoreD(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Multiply two images.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <param name="mult">Factor for gray range adaption. Default: 0.005</param>
		/// <param name="add">Value for gray range adaption. Default: 0</param>
		/// <returns>Result image(s) by the product.</returns>
		// Token: 0x060008B0 RID: 2224 RVA: 0x00037FD4 File Offset: 0x000361D4
		public HImage MultImage(HImage image2, HTuple mult, HTuple add)
		{
			IntPtr proc = HalconAPI.PreCall(1609);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, mult);
			HalconAPI.Store(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mult);
			HalconAPI.UnpinTuple(add);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Multiply two images.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <param name="mult">Factor for gray range adaption. Default: 0.005</param>
		/// <param name="add">Value for gray range adaption. Default: 0</param>
		/// <returns>Result image(s) by the product.</returns>
		// Token: 0x060008B1 RID: 2225 RVA: 0x00038048 File Offset: 0x00036248
		public HImage MultImage(HImage image2, double mult, double add)
		{
			IntPtr proc = HalconAPI.PreCall(1609);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.StoreD(proc, 0, mult);
			HalconAPI.StoreD(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Add two images.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <param name="mult">Factor for gray value adaption. Default: 0.5</param>
		/// <param name="add">Value for gray value range adaption. Default: 0</param>
		/// <returns>Result image(s) by the addition.</returns>
		// Token: 0x060008B2 RID: 2226 RVA: 0x000380B0 File Offset: 0x000362B0
		public HImage AddImage(HImage image2, HTuple mult, HTuple add)
		{
			IntPtr proc = HalconAPI.PreCall(1610);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, mult);
			HalconAPI.Store(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mult);
			HalconAPI.UnpinTuple(add);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Add two images.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <param name="mult">Factor for gray value adaption. Default: 0.5</param>
		/// <param name="add">Value for gray value range adaption. Default: 0</param>
		/// <returns>Result image(s) by the addition.</returns>
		// Token: 0x060008B3 RID: 2227 RVA: 0x00038124 File Offset: 0x00036324
		public HImage AddImage(HImage image2, double mult, double add)
		{
			IntPtr proc = HalconAPI.PreCall(1610);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.StoreD(proc, 0, mult);
			HalconAPI.StoreD(proc, 1, add);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Calculate the absolute value (modulus) of an image.
		///   Instance represents: Image(s) for which the absolute gray values are to be calculated.
		/// </summary>
		/// <returns>Result image(s).</returns>
		// Token: 0x060008B4 RID: 2228 RVA: 0x0003818C File Offset: 0x0003638C
		public HImage AbsImage()
		{
			IntPtr proc = HalconAPI.PreCall(1611);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the minimum of two images pixel by pixel.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <returns>Result image(s) by the minimization.</returns>
		// Token: 0x060008B5 RID: 2229 RVA: 0x000381D4 File Offset: 0x000363D4
		public HImage MinImage(HImage image2)
		{
			IntPtr proc = HalconAPI.PreCall(1612);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Calculate the maximum of two images pixel by pixel.
		///   Instance represents: Image(s) 1.
		/// </summary>
		/// <param name="image2">Image(s) 2.</param>
		/// <returns>Result image(s) by the maximization.</returns>
		// Token: 0x060008B6 RID: 2230 RVA: 0x0003822C File Offset: 0x0003642C
		public HImage MaxImage(HImage image2)
		{
			IntPtr proc = HalconAPI.PreCall(1613);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Invert an image.
		///   Instance represents: Input image(s).
		/// </summary>
		/// <returns>Image(s) with inverted gray values.</returns>
		// Token: 0x060008B7 RID: 2231 RVA: 0x00038284 File Offset: 0x00036484
		public HImage InvertImage()
		{
			IntPtr proc = HalconAPI.PreCall(1614);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an automatic color correction to panorama images.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="from">List of source images.</param>
		/// <param name="to">List of destination images.</param>
		/// <param name="referenceImage">Reference image.</param>
		/// <param name="homMatrices2D">Projective matrices.</param>
		/// <param name="estimationMethod">Estimation algorithm for the correction. Default: "standard"</param>
		/// <param name="estimateParameters">Parameters to be estimated. Default: ["mult_gray"]</param>
		/// <param name="OECFModel">Model of OECF to be used. Default: ["laguerre"]</param>
		/// <returns>Output images.</returns>
		// Token: 0x060008B8 RID: 2232 RVA: 0x000382CC File Offset: 0x000364CC
		public HImage AdjustMosaicImages(HTuple from, HTuple to, int referenceImage, HTuple homMatrices2D, string estimationMethod, HTuple estimateParameters, string OECFModel)
		{
			IntPtr proc = HalconAPI.PreCall(1615);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, from);
			HalconAPI.Store(proc, 1, to);
			HalconAPI.StoreI(proc, 2, referenceImage);
			HalconAPI.Store(proc, 3, homMatrices2D);
			HalconAPI.StoreS(proc, 4, estimationMethod);
			HalconAPI.Store(proc, 5, estimateParameters);
			HalconAPI.StoreS(proc, 6, OECFModel);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(from);
			HalconAPI.UnpinTuple(to);
			HalconAPI.UnpinTuple(homMatrices2D);
			HalconAPI.UnpinTuple(estimateParameters);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an automatic color correction to panorama images.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="from">List of source images.</param>
		/// <param name="to">List of destination images.</param>
		/// <param name="referenceImage">Reference image.</param>
		/// <param name="homMatrices2D">Projective matrices.</param>
		/// <param name="estimationMethod">Estimation algorithm for the correction. Default: "standard"</param>
		/// <param name="estimateParameters">Parameters to be estimated. Default: ["mult_gray"]</param>
		/// <param name="OECFModel">Model of OECF to be used. Default: ["laguerre"]</param>
		/// <returns>Output images.</returns>
		// Token: 0x060008B9 RID: 2233 RVA: 0x0003836C File Offset: 0x0003656C
		public HImage AdjustMosaicImages(HTuple from, HTuple to, int referenceImage, HTuple homMatrices2D, string estimationMethod, string estimateParameters, string OECFModel)
		{
			IntPtr proc = HalconAPI.PreCall(1615);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, from);
			HalconAPI.Store(proc, 1, to);
			HalconAPI.StoreI(proc, 2, referenceImage);
			HalconAPI.Store(proc, 3, homMatrices2D);
			HalconAPI.StoreS(proc, 4, estimationMethod);
			HalconAPI.StoreS(proc, 5, estimateParameters);
			HalconAPI.StoreS(proc, 6, OECFModel);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(from);
			HalconAPI.UnpinTuple(to);
			HalconAPI.UnpinTuple(homMatrices2D);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create 6 cube map images of a spherical mosaic.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="rear">Rear cube map.</param>
		/// <param name="left">Left cube map.</param>
		/// <param name="right">Right cube map.</param>
		/// <param name="top">Top cube map.</param>
		/// <param name="bottom">Bottom cube map.</param>
		/// <param name="cameraMatrices">(Array of) 3x3 projective camera matrices that determine the internal camera parameters.</param>
		/// <param name="rotationMatrices">Array of 3x3 transformation matrices that determine rotation of the camera in the respective image.</param>
		/// <param name="cubeMapDimension">Width and height of the resulting cube maps. Default: 1000</param>
		/// <param name="stackingOrder">Mode of adding the images to the mosaic image. Default: "voronoi"</param>
		/// <param name="interpolation">Mode of image interpolation. Default: "bilinear"</param>
		/// <returns>Front cube map.</returns>
		// Token: 0x060008BA RID: 2234 RVA: 0x00038404 File Offset: 0x00036604
		public HImage GenCubeMapMosaic(out HImage rear, out HImage left, out HImage right, out HImage top, out HImage bottom, HHomMat2D[] cameraMatrices, HHomMat2D[] rotationMatrices, int cubeMapDimension, HTuple stackingOrder, string interpolation)
		{
			HTuple htuple = HData.ConcatArray(cameraMatrices);
			HTuple htuple2 = HData.ConcatArray(rotationMatrices);
			IntPtr proc = HalconAPI.PreCall(1616);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.StoreI(proc, 2, cubeMapDimension);
			HalconAPI.Store(proc, 3, stackingOrder);
			HalconAPI.StoreS(proc, 4, interpolation);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HalconAPI.UnpinTuple(stackingOrder);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out rear);
			num = HImage.LoadNew(proc, 3, num, out left);
			num = HImage.LoadNew(proc, 4, num, out right);
			num = HImage.LoadNew(proc, 5, num, out top);
			num = HImage.LoadNew(proc, 6, num, out bottom);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create 6 cube map images of a spherical mosaic.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="rear">Rear cube map.</param>
		/// <param name="left">Left cube map.</param>
		/// <param name="right">Right cube map.</param>
		/// <param name="top">Top cube map.</param>
		/// <param name="bottom">Bottom cube map.</param>
		/// <param name="cameraMatrices">(Array of) 3x3 projective camera matrices that determine the internal camera parameters.</param>
		/// <param name="rotationMatrices">Array of 3x3 transformation matrices that determine rotation of the camera in the respective image.</param>
		/// <param name="cubeMapDimension">Width and height of the resulting cube maps. Default: 1000</param>
		/// <param name="stackingOrder">Mode of adding the images to the mosaic image. Default: "voronoi"</param>
		/// <param name="interpolation">Mode of image interpolation. Default: "bilinear"</param>
		/// <returns>Front cube map.</returns>
		// Token: 0x060008BB RID: 2235 RVA: 0x00038500 File Offset: 0x00036700
		public HImage GenCubeMapMosaic(out HImage rear, out HImage left, out HImage right, out HImage top, out HImage bottom, HHomMat2D[] cameraMatrices, HHomMat2D[] rotationMatrices, int cubeMapDimension, string stackingOrder, string interpolation)
		{
			HTuple htuple = HData.ConcatArray(cameraMatrices);
			HTuple htuple2 = HData.ConcatArray(rotationMatrices);
			IntPtr proc = HalconAPI.PreCall(1616);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.StoreI(proc, 2, cubeMapDimension);
			HalconAPI.StoreS(proc, 3, stackingOrder);
			HalconAPI.StoreS(proc, 4, interpolation);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out rear);
			num = HImage.LoadNew(proc, 3, num, out left);
			num = HImage.LoadNew(proc, 4, num, out right);
			num = HImage.LoadNew(proc, 5, num, out top);
			num = HImage.LoadNew(proc, 6, num, out bottom);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create a spherical mosaic image.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="cameraMatrices">(Array of) 3x3 projective camera matrices that determine the internal camera parameters.</param>
		/// <param name="rotationMatrices">Array of 3x3 transformation matrices that determine rotation of the camera in the respective image.</param>
		/// <param name="latMin">Minimum latitude of points in the spherical mosaic image. Default: -90</param>
		/// <param name="latMax">Maximum latitude of points in the spherical mosaic image. Default: 90</param>
		/// <param name="longMin">Minimum longitude of points in the spherical mosaic image. Default: -180</param>
		/// <param name="longMax">Maximum longitude of points in the spherical mosaic image. Default: 180</param>
		/// <param name="latLongStep">Latitude and longitude angle step width. Default: 0.1</param>
		/// <param name="stackingOrder">Mode of adding the images to the mosaic image. Default: "voronoi"</param>
		/// <param name="interpolation">Mode of interpolation when creating the mosaic image. Default: "bilinear"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008BC RID: 2236 RVA: 0x000385F4 File Offset: 0x000367F4
		public HImage GenSphericalMosaic(HHomMat2D[] cameraMatrices, HHomMat2D[] rotationMatrices, HTuple latMin, HTuple latMax, HTuple longMin, HTuple longMax, HTuple latLongStep, HTuple stackingOrder, HTuple interpolation)
		{
			HTuple htuple = HData.ConcatArray(cameraMatrices);
			HTuple htuple2 = HData.ConcatArray(rotationMatrices);
			IntPtr proc = HalconAPI.PreCall(1617);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.Store(proc, 2, latMin);
			HalconAPI.Store(proc, 3, latMax);
			HalconAPI.Store(proc, 4, longMin);
			HalconAPI.Store(proc, 5, longMax);
			HalconAPI.Store(proc, 6, latLongStep);
			HalconAPI.Store(proc, 7, stackingOrder);
			HalconAPI.Store(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HalconAPI.UnpinTuple(latMin);
			HalconAPI.UnpinTuple(latMax);
			HalconAPI.UnpinTuple(longMin);
			HalconAPI.UnpinTuple(longMax);
			HalconAPI.UnpinTuple(latLongStep);
			HalconAPI.UnpinTuple(stackingOrder);
			HalconAPI.UnpinTuple(interpolation);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create a spherical mosaic image.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="cameraMatrices">(Array of) 3x3 projective camera matrices that determine the internal camera parameters.</param>
		/// <param name="rotationMatrices">Array of 3x3 transformation matrices that determine rotation of the camera in the respective image.</param>
		/// <param name="latMin">Minimum latitude of points in the spherical mosaic image. Default: -90</param>
		/// <param name="latMax">Maximum latitude of points in the spherical mosaic image. Default: 90</param>
		/// <param name="longMin">Minimum longitude of points in the spherical mosaic image. Default: -180</param>
		/// <param name="longMax">Maximum longitude of points in the spherical mosaic image. Default: 180</param>
		/// <param name="latLongStep">Latitude and longitude angle step width. Default: 0.1</param>
		/// <param name="stackingOrder">Mode of adding the images to the mosaic image. Default: "voronoi"</param>
		/// <param name="interpolation">Mode of interpolation when creating the mosaic image. Default: "bilinear"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008BD RID: 2237 RVA: 0x000386E0 File Offset: 0x000368E0
		public HImage GenSphericalMosaic(HHomMat2D[] cameraMatrices, HHomMat2D[] rotationMatrices, double latMin, double latMax, double longMin, double longMax, double latLongStep, string stackingOrder, string interpolation)
		{
			HTuple htuple = HData.ConcatArray(cameraMatrices);
			HTuple htuple2 = HData.ConcatArray(rotationMatrices);
			IntPtr proc = HalconAPI.PreCall(1617);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, htuple2);
			HalconAPI.StoreD(proc, 2, latMin);
			HalconAPI.StoreD(proc, 3, latMax);
			HalconAPI.StoreD(proc, 4, longMin);
			HalconAPI.StoreD(proc, 5, longMax);
			HalconAPI.StoreD(proc, 6, latLongStep);
			HalconAPI.StoreS(proc, 7, stackingOrder);
			HalconAPI.StoreS(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(htuple2);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Combine multiple images into a mosaic image.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="stackingOrder">Stacking order of the images in the mosaic. Default: "default"</param>
		/// <param name="transformDomain">Should the domains of the input images also be transformed? Default: "false"</param>
		/// <param name="transMat2D">3x3 projective transformation matrix that describes the translation that was necessary to transform all images completely into the output image.</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008BE RID: 2238 RVA: 0x0003879C File Offset: 0x0003699C
		public HImage GenBundleAdjustedMosaic(HHomMat2D[] homMatrices2D, HTuple stackingOrder, string transformDomain, out HHomMat2D transMat2D)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(1618);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, stackingOrder);
			HalconAPI.StoreS(proc, 2, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(stackingOrder);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HHomMat2D.LoadNew(proc, 0, num, out transMat2D);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Combine multiple images into a mosaic image.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="stackingOrder">Stacking order of the images in the mosaic. Default: "default"</param>
		/// <param name="transformDomain">Should the domains of the input images also be transformed? Default: "false"</param>
		/// <param name="transMat2D">3x3 projective transformation matrix that describes the translation that was necessary to transform all images completely into the output image.</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008BF RID: 2239 RVA: 0x00038828 File Offset: 0x00036A28
		public HImage GenBundleAdjustedMosaic(HHomMat2D[] homMatrices2D, string stackingOrder, string transformDomain, out HHomMat2D transMat2D)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(1618);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.StoreS(proc, 1, stackingOrder);
			HalconAPI.StoreS(proc, 2, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HHomMat2D.LoadNew(proc, 0, num, out transMat2D);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Combine multiple images into a mosaic image.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="startImage">Index of the central input image.</param>
		/// <param name="mappingSource">Indices of the source images of the transformations.</param>
		/// <param name="mappingDest">Indices of the target images of the transformations.</param>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="stackingOrder">Stacking order of the images in the mosaic. Default: "default"</param>
		/// <param name="transformDomain">Should the domains of the input images also be transformed? Default: "false"</param>
		/// <param name="mosaicMatrices2D">Array of 3x3 projective transformation matrices that determine the position of the images in the mosaic.</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008C0 RID: 2240 RVA: 0x000388AC File Offset: 0x00036AAC
		public HImage GenProjectiveMosaic(int startImage, HTuple mappingSource, HTuple mappingDest, HHomMat2D[] homMatrices2D, HTuple stackingOrder, string transformDomain, out HHomMat2D[] mosaicMatrices2D)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(1619);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, startImage);
			HalconAPI.Store(proc, 1, mappingSource);
			HalconAPI.Store(proc, 2, mappingDest);
			HalconAPI.Store(proc, 3, htuple);
			HalconAPI.Store(proc, 4, stackingOrder);
			HalconAPI.StoreS(proc, 5, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mappingSource);
			HalconAPI.UnpinTuple(mappingDest);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(stackingOrder);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			mosaicMatrices2D = HHomMat2D.SplitArray(data);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Combine multiple images into a mosaic image.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="startImage">Index of the central input image.</param>
		/// <param name="mappingSource">Indices of the source images of the transformations.</param>
		/// <param name="mappingDest">Indices of the target images of the transformations.</param>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="stackingOrder">Stacking order of the images in the mosaic. Default: "default"</param>
		/// <param name="transformDomain">Should the domains of the input images also be transformed? Default: "false"</param>
		/// <param name="mosaicMatrices2D">Array of 3x3 projective transformation matrices that determine the position of the images in the mosaic.</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008C1 RID: 2241 RVA: 0x00038968 File Offset: 0x00036B68
		public HImage GenProjectiveMosaic(int startImage, HTuple mappingSource, HTuple mappingDest, HHomMat2D[] homMatrices2D, string stackingOrder, string transformDomain, out HHomMat2D[] mosaicMatrices2D)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(1619);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, startImage);
			HalconAPI.Store(proc, 1, mappingSource);
			HalconAPI.Store(proc, 2, mappingDest);
			HalconAPI.Store(proc, 3, htuple);
			HalconAPI.StoreS(proc, 4, stackingOrder);
			HalconAPI.StoreS(proc, 5, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mappingSource);
			HalconAPI.UnpinTuple(mappingDest);
			HalconAPI.UnpinTuple(htuple);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			mosaicMatrices2D = HHomMat2D.SplitArray(data);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply a projective transformation to an image and specify the output image size.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="homMat2D">Homogeneous projective transformation matrix.</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "bilinear"</param>
		/// <param name="width">Output image width.</param>
		/// <param name="height">Output image height.</param>
		/// <param name="transformDomain">Should the domain of the input image also be transformed? Default: "false"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008C2 RID: 2242 RVA: 0x00038A20 File Offset: 0x00036C20
		public HImage ProjectiveTransImageSize(HHomMat2D homMat2D, string interpolation, int width, int height, string transformDomain)
		{
			IntPtr proc = HalconAPI.PreCall(1620);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.StoreS(proc, 4, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply a projective transformation to an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="homMat2D">Homogeneous projective transformation matrix.</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "bilinear"</param>
		/// <param name="adaptImageSize">Adapt the size of the output image automatically? Default: "false"</param>
		/// <param name="transformDomain">Should the domain of the input image also be transformed? Default: "false"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008C3 RID: 2243 RVA: 0x00038AA4 File Offset: 0x00036CA4
		public HImage ProjectiveTransImage(HHomMat2D homMat2D, string interpolation, string adaptImageSize, string transformDomain)
		{
			IntPtr proc = HalconAPI.PreCall(1621);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreS(proc, 2, adaptImageSize);
			HalconAPI.StoreS(proc, 3, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to an image and specify the output image size.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="homMat2D">Input transformation matrix.</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <param name="width">Width of the output image. Default: 640</param>
		/// <param name="height">Height of the output image. Default: 480</param>
		/// <returns>Transformed image.</returns>
		// Token: 0x060008C4 RID: 2244 RVA: 0x00038B20 File Offset: 0x00036D20
		public HImage AffineTransImageSize(HHomMat2D homMat2D, string interpolation, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1622);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to images.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="homMat2D">Input transformation matrix.</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <param name="adaptImageSize">Adaption of size of result image. Default: "false"</param>
		/// <returns>Transformed image.</returns>
		// Token: 0x060008C5 RID: 2245 RVA: 0x00038B9C File Offset: 0x00036D9C
		public HImage AffineTransImage(HHomMat2D homMat2D, string interpolation, string adaptImageSize)
		{
			IntPtr proc = HalconAPI.PreCall(1623);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreS(proc, 2, adaptImageSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Zoom an image by a given factor.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="scaleWidth">Scale factor for the width of the image. Default: 0.5</param>
		/// <param name="scaleHeight">Scale factor for the height of the image. Default: 0.5</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <returns>Scaled image.</returns>
		// Token: 0x060008C6 RID: 2246 RVA: 0x00038C0C File Offset: 0x00036E0C
		public HImage ZoomImageFactor(double scaleWidth, double scaleHeight, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1624);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, scaleWidth);
			HalconAPI.StoreD(proc, 1, scaleHeight);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Zoom an image to a given size.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="width">Width of the resulting image. Default: 512</param>
		/// <param name="height">Height of the resulting image. Default: 512</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <returns>Scaled image.</returns>
		// Token: 0x060008C7 RID: 2247 RVA: 0x00038C6C File Offset: 0x00036E6C
		public HImage ZoomImageSize(int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1625);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Mirror an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="mode">Axis of reflection. Default: "row"</param>
		/// <returns>Reflected image.</returns>
		// Token: 0x060008C8 RID: 2248 RVA: 0x00038CCC File Offset: 0x00036ECC
		public HImage MirrorImage(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1626);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Rotate an image about its center.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 90</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <returns>Rotated image.</returns>
		// Token: 0x060008C9 RID: 2249 RVA: 0x00038D1C File Offset: 0x00036F1C
		public HImage RotateImage(HTuple phi, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1627);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, phi);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(phi);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Rotate an image about its center.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 90</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <returns>Rotated image.</returns>
		// Token: 0x060008CA RID: 2250 RVA: 0x00038D7C File Offset: 0x00036F7C
		public HImage RotateImage(double phi, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1627);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, phi);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an image in polar coordinates back to cartesian coordinates
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to map the first column of the input image to. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to map the last column of the input image to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to map the first row of the input image to. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to map the last row of the input image to. Default: 100</param>
		/// <param name="width">Width of the output image. Default: 512</param>
		/// <param name="height">Height of the output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008CB RID: 2251 RVA: 0x00038DD4 File Offset: 0x00036FD4
		public HImage PolarTransImageInv(HTuple row, HTuple column, double angleStart, double angleEnd, HTuple radiusStart, HTuple radiusEnd, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1628);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.Store(proc, 4, radiusStart);
			HalconAPI.Store(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.StoreS(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radiusStart);
			HalconAPI.UnpinTuple(radiusEnd);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an image in polar coordinates back to cartesian coordinates
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to map the first column of the input image to. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to map the last column of the input image to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to map the first row of the input image to. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to map the last row of the input image to. Default: 100</param>
		/// <param name="width">Width of the output image. Default: 512</param>
		/// <param name="height">Height of the output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008CC RID: 2252 RVA: 0x00038E84 File Offset: 0x00037084
		public HImage PolarTransImageInv(double row, double column, double angleStart, double angleEnd, double radiusStart, double radiusEnd, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1628);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.StoreD(proc, 4, radiusStart);
			HalconAPI.StoreD(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.StoreS(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an annular arc in an image to polar coordinates.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to be mapped to the first column of the output image. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to be mapped to the last column of the output image. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to be mapped to the first row of the output image. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to be mapped to the last row of the output image. Default: 100</param>
		/// <param name="width">Width of the output image. Default: 512</param>
		/// <param name="height">Height of the output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008CD RID: 2253 RVA: 0x00038F1C File Offset: 0x0003711C
		public HImage PolarTransImageExt(HTuple row, HTuple column, double angleStart, double angleEnd, HTuple radiusStart, HTuple radiusEnd, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1629);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.Store(proc, 4, radiusStart);
			HalconAPI.Store(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.StoreS(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radiusStart);
			HalconAPI.UnpinTuple(radiusEnd);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an annular arc in an image to polar coordinates.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to be mapped to the first column of the output image. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to be mapped to the last column of the output image. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to be mapped to the first row of the output image. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to be mapped to the last row of the output image. Default: 100</param>
		/// <param name="width">Width of the output image. Default: 512</param>
		/// <param name="height">Height of the output image. Default: 512</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "nearest_neighbor"</param>
		/// <returns>Output image.</returns>
		// Token: 0x060008CE RID: 2254 RVA: 0x00038FCC File Offset: 0x000371CC
		public HImage PolarTransImageExt(double row, double column, double angleStart, double angleEnd, double radiusStart, double radiusEnd, int width, int height, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1629);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.StoreD(proc, 4, radiusStart);
			HalconAPI.StoreD(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.StoreS(proc, 8, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an image to polar coordinates
		///   Instance represents: Input image in cartesian coordinates.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the coordinate system. Default: 100</param>
		/// <param name="column">Column coordinate of the center of the coordinate system. Default: 100</param>
		/// <param name="width">Width of the result image. Default: 314</param>
		/// <param name="height">Height of the result image. Default: 200</param>
		/// <returns>Result image in polar coordinates.</returns>
		// Token: 0x060008CF RID: 2255 RVA: 0x00039064 File Offset: 0x00037264
		public HImage PolarTransImage(int row, int column, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1630);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Approximate an affine map from a displacement vector field.
		///   Instance represents: Input image.
		/// </summary>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x060008D0 RID: 2256 RVA: 0x000390D0 File Offset: 0x000372D0
		public HHomMat2D VectorFieldToHomMat2d()
		{
			IntPtr proc = HalconAPI.PreCall(1631);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Deserialize a serialized image object.
		///   Modified instance represents: Image object.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x060008D1 RID: 2257 RVA: 0x00039118 File Offset: 0x00037318
		public void DeserializeImage(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1650);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize an image object.
		///   Instance represents: Image object.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x060008D2 RID: 2258 RVA: 0x0003916C File Offset: 0x0003736C
		public HSerializedItem SerializeImage()
		{
			IntPtr proc = HalconAPI.PreCall(1651);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Write images in graphic formats.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="format">Graphic format. Default: "tiff"</param>
		/// <param name="fillColor">Fill gray value for pixels not belonging to the image domain (region). Default: 0</param>
		/// <param name="fileName">Name of image file.</param>
		// Token: 0x060008D3 RID: 2259 RVA: 0x000391B4 File Offset: 0x000373B4
		public void WriteImage(string format, HTuple fillColor, HTuple fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1655);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, format);
			HalconAPI.Store(proc, 1, fillColor);
			HalconAPI.Store(proc, 2, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(fillColor);
			HalconAPI.UnpinTuple(fileName);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write images in graphic formats.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="format">Graphic format. Default: "tiff"</param>
		/// <param name="fillColor">Fill gray value for pixels not belonging to the image domain (region). Default: 0</param>
		/// <param name="fileName">Name of image file.</param>
		// Token: 0x060008D4 RID: 2260 RVA: 0x0003920C File Offset: 0x0003740C
		public void WriteImage(string format, int fillColor, string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1655);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, format);
			HalconAPI.StoreI(proc, 1, fillColor);
			HalconAPI.StoreS(proc, 2, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read images.
		///   Modified instance represents: Image read.
		/// </summary>
		/// <param name="headerSize">Number of bytes for file header. Default: 0</param>
		/// <param name="sourceWidth">Number of image columns of the filed image. Default: 512</param>
		/// <param name="sourceHeight">Number of image lines of the filed image. Default: 512</param>
		/// <param name="startRow">Starting point of image area (line). Default: 0</param>
		/// <param name="startColumn">Starting point of image area (column). Default: 0</param>
		/// <param name="destWidth">Number of image columns of output image. Default: 512</param>
		/// <param name="destHeight">Number of image lines of output image. Default: 512</param>
		/// <param name="pixelType">Type of pixel values. Default: "byte"</param>
		/// <param name="bitOrder">Sequence of bits within one byte. Default: "MSBFirst"</param>
		/// <param name="byteOrder">Sequence of bytes within one 'short' unit. Default: "MSBFirst"</param>
		/// <param name="pad">Data units within one image line (alignment). Default: "byte"</param>
		/// <param name="index">Number of images in the file. Default: 1</param>
		/// <param name="fileName">Name of input file.</param>
		// Token: 0x060008D5 RID: 2261 RVA: 0x00039258 File Offset: 0x00037458
		public void ReadSequence(int headerSize, int sourceWidth, int sourceHeight, int startRow, int startColumn, int destWidth, int destHeight, string pixelType, string bitOrder, string byteOrder, string pad, int index, string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1656);
			HalconAPI.StoreI(proc, 0, headerSize);
			HalconAPI.StoreI(proc, 1, sourceWidth);
			HalconAPI.StoreI(proc, 2, sourceHeight);
			HalconAPI.StoreI(proc, 3, startRow);
			HalconAPI.StoreI(proc, 4, startColumn);
			HalconAPI.StoreI(proc, 5, destWidth);
			HalconAPI.StoreI(proc, 6, destHeight);
			HalconAPI.StoreS(proc, 7, pixelType);
			HalconAPI.StoreS(proc, 8, bitOrder);
			HalconAPI.StoreS(proc, 9, byteOrder);
			HalconAPI.StoreS(proc, 10, pad);
			HalconAPI.StoreI(proc, 11, index);
			HalconAPI.StoreS(proc, 12, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read an image with different file formats.
		///   Modified instance represents: Read image.
		/// </summary>
		/// <param name="fileName">Name of the image to be read. Default: "printer_chip/printer_chip_01"</param>
		// Token: 0x060008D6 RID: 2262 RVA: 0x00039314 File Offset: 0x00037514
		public void ReadImage(HTuple fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1658);
			HalconAPI.Store(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(fileName);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read an image with different file formats.
		///   Modified instance represents: Read image.
		/// </summary>
		/// <param name="fileName">Name of the image to be read. Default: "printer_chip/printer_chip_01"</param>
		// Token: 0x060008D7 RID: 2263 RVA: 0x00039368 File Offset: 0x00037568
		public void ReadImage(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1658);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return gray values of an image at the positions of an XLD contour.
		///   Instance represents: Image whose gray values are to be accessed.
		/// </summary>
		/// <param name="contour">Input XLD contour with the coordinates of the positions.</param>
		/// <param name="interpolation">Interpolation method. Default: "nearest_neighbor"</param>
		/// <returns>Gray values of the selected image coordinates.</returns>
		// Token: 0x060008D8 RID: 2264 RVA: 0x000393B4 File Offset: 0x000375B4
		public HTuple GetGrayvalContourXld(HXLDCont contour, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1668);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contour);
			HalconAPI.StoreS(proc, 0, interpolation);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contour);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a first order surface (plane).
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Regions to be checked.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060008D9 RID: 2265 RVA: 0x00039414 File Offset: 0x00037614
		public HTuple FitSurfaceFirstOrder(HRegion regions, string algorithm, int iterations, double clippingFactor, out HTuple beta, out HTuple gamma)
		{
			IntPtr proc = HalconAPI.PreCall(1743);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out beta);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out gamma);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a first order surface (plane).
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Regions to be checked.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060008DA RID: 2266 RVA: 0x000394AC File Offset: 0x000376AC
		public double FitSurfaceFirstOrder(HRegion regions, string algorithm, int iterations, double clippingFactor, out double beta, out double gamma)
		{
			IntPtr proc = HalconAPI.PreCall(1743);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out beta);
			num = HalconAPI.LoadD(proc, 2, num, out gamma);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a second order surface.
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Regions to be checked.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <param name="delta">Parameter Delta of the approximating surface.</param>
		/// <param name="epsilon">Parameter Epsilon of the approximating surface.</param>
		/// <param name="zeta">Parameter Zeta of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060008DB RID: 2267 RVA: 0x00039544 File Offset: 0x00037744
		public HTuple FitSurfaceSecondOrder(HRegion regions, string algorithm, int iterations, double clippingFactor, out HTuple beta, out HTuple gamma, out HTuple delta, out HTuple epsilon, out HTuple zeta)
		{
			IntPtr proc = HalconAPI.PreCall(1744);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out beta);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out gamma);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out delta);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out epsilon);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out zeta);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a second order surface.
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Regions to be checked.</param>
		/// <param name="algorithm">Algorithm for the fitting. Default: "regression"</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers. Default: 2.0</param>
		/// <param name="beta">Parameter Beta of the approximating surface.</param>
		/// <param name="gamma">Parameter Gamma of the approximating surface.</param>
		/// <param name="delta">Parameter Delta of the approximating surface.</param>
		/// <param name="epsilon">Parameter Epsilon of the approximating surface.</param>
		/// <param name="zeta">Parameter Zeta of the approximating surface.</param>
		/// <returns>Parameter Alpha of the approximating surface.</returns>
		// Token: 0x060008DC RID: 2268 RVA: 0x00039618 File Offset: 0x00037818
		public double FitSurfaceSecondOrder(HRegion regions, string algorithm, int iterations, double clippingFactor, out double beta, out double gamma, out double delta, out double epsilon, out double zeta)
		{
			IntPtr proc = HalconAPI.PreCall(1744);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.StoreD(proc, 2, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out beta);
			num = HalconAPI.LoadD(proc, 2, num, out gamma);
			num = HalconAPI.LoadD(proc, 3, num, out delta);
			num = HalconAPI.LoadD(proc, 4, num, out epsilon);
			num = HalconAPI.LoadD(proc, 5, num, out zeta);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Create a curved gray surface with second order polynomial.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="alpha">Second order coefficient in vertical direction. Default: 1.0</param>
		/// <param name="beta">Second order coefficient in horizontal direction. Default: 1.0</param>
		/// <param name="gamma">Mixed second order coefficient. Default: 1.0</param>
		/// <param name="delta">First order coefficient in vertical direction. Default: 1.0</param>
		/// <param name="epsilon">First order coefficient in horizontal direction. Default: 1.0</param>
		/// <param name="zeta">Zero order coefficient. Default: 1.0</param>
		/// <param name="row">Row coordinate of the reference point of the surface. Default: 256.0</param>
		/// <param name="column">Column coordinate of the reference point of the surface. Default: 256.0</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		// Token: 0x060008DD RID: 2269 RVA: 0x000396E8 File Offset: 0x000378E8
		public void GenImageSurfaceSecondOrder(string type, double alpha, double beta, double gamma, double delta, double epsilon, double zeta, double row, double column, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1745);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.StoreD(proc, 2, beta);
			HalconAPI.StoreD(proc, 3, gamma);
			HalconAPI.StoreD(proc, 4, delta);
			HalconAPI.StoreD(proc, 5, epsilon);
			HalconAPI.StoreD(proc, 6, zeta);
			HalconAPI.StoreD(proc, 7, row);
			HalconAPI.StoreD(proc, 8, column);
			HalconAPI.StoreI(proc, 9, width);
			HalconAPI.StoreI(proc, 10, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a tilted gray surface with first order polynomial.
		///   Modified instance represents: Created image with new image matrix.
		/// </summary>
		/// <param name="type">Pixel type. Default: "byte"</param>
		/// <param name="alpha">First order coefficient in vertical direction. Default: 1.0</param>
		/// <param name="beta">First order coefficient in horizontal direction. Default: 1.0</param>
		/// <param name="gamma">Zero order coefficient. Default: 1.0</param>
		/// <param name="row">Row coordinate of the reference point of the surface. Default: 256.0</param>
		/// <param name="column">Column coordinate of the reference point of the surface. Default: 256.0</param>
		/// <param name="width">Width of image. Default: 512</param>
		/// <param name="height">Height of image. Default: 512</param>
		// Token: 0x060008DE RID: 2270 RVA: 0x00039790 File Offset: 0x00037990
		public void GenImageSurfaceFirstOrder(string type, double alpha, double beta, double gamma, double row, double column, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1746);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.StoreD(proc, 2, beta);
			HalconAPI.StoreD(proc, 3, gamma);
			HalconAPI.StoreD(proc, 4, row);
			HalconAPI.StoreD(proc, 5, column);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Determine the minimum and maximum gray values within regions.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Regions, the features of which are to be calculated.</param>
		/// <param name="percent">Percentage below (above) the absolute maximum (minimum). Default: 0</param>
		/// <param name="min">"Minimum" gray value.</param>
		/// <param name="max">"Maximum" gray value.</param>
		/// <param name="range">Difference between Max and Min.</param>
		// Token: 0x060008DF RID: 2271 RVA: 0x0003981C File Offset: 0x00037A1C
		public void MinMaxGray(HRegion regions, HTuple percent, out HTuple min, out HTuple max, out HTuple range)
		{
			IntPtr proc = HalconAPI.PreCall(1751);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 0, percent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(percent);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out min);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out max);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out range);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
		}

		/// <summary>
		///   Determine the minimum and maximum gray values within regions.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Regions, the features of which are to be calculated.</param>
		/// <param name="percent">Percentage below (above) the absolute maximum (minimum). Default: 0</param>
		/// <param name="min">"Minimum" gray value.</param>
		/// <param name="max">"Maximum" gray value.</param>
		/// <param name="range">Difference between Max and Min.</param>
		// Token: 0x060008E0 RID: 2272 RVA: 0x000398A8 File Offset: 0x00037AA8
		public void MinMaxGray(HRegion regions, double percent, out double min, out double max, out double range)
		{
			IntPtr proc = HalconAPI.PreCall(1751);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreD(proc, 0, percent);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out min);
			num = HalconAPI.LoadD(proc, 1, num, out max);
			num = HalconAPI.LoadD(proc, 2, num, out range);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
		}

		/// <summary>
		///   Calculate the mean and deviation of gray values.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Regions in which the features are calculated.</param>
		/// <param name="deviation">Deviation of gray values within a region.</param>
		/// <returns>Mean gray value of a region.</returns>
		// Token: 0x060008E1 RID: 2273 RVA: 0x0003992C File Offset: 0x00037B2C
		public HTuple Intensity(HRegion regions, out HTuple deviation)
		{
			IntPtr proc = HalconAPI.PreCall(1752);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out deviation);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the mean and deviation of gray values.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Regions in which the features are calculated.</param>
		/// <param name="deviation">Deviation of gray values within a region.</param>
		/// <returns>Mean gray value of a region.</returns>
		// Token: 0x060008E2 RID: 2274 RVA: 0x00039998 File Offset: 0x00037B98
		public double Intensity(HRegion regions, out double deviation)
		{
			IntPtr proc = HalconAPI.PreCall(1752);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out deviation);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution of a single channel image within a certain gray value range.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="regions">Region in which the histogram is to be calculated.</param>
		/// <param name="min">Minimum gray value. Default: 0</param>
		/// <param name="max">Maximum gray value. Default: 255</param>
		/// <param name="numBins">Number of bins. Default: 256</param>
		/// <param name="binSize">Bin size.</param>
		/// <returns>Histogram to be calculated.</returns>
		// Token: 0x060008E3 RID: 2275 RVA: 0x00039A00 File Offset: 0x00037C00
		public HTuple GrayHistoRange(HRegion regions, HTuple min, HTuple max, int numBins, out double binSize)
		{
			IntPtr proc = HalconAPI.PreCall(1753);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 0, min);
			HalconAPI.Store(proc, 1, max);
			HalconAPI.StoreI(proc, 2, numBins);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out binSize);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution of a single channel image within a certain gray value range.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="regions">Region in which the histogram is to be calculated.</param>
		/// <param name="min">Minimum gray value. Default: 0</param>
		/// <param name="max">Maximum gray value. Default: 255</param>
		/// <param name="numBins">Number of bins. Default: 256</param>
		/// <param name="binSize">Bin size.</param>
		/// <returns>Histogram to be calculated.</returns>
		// Token: 0x060008E4 RID: 2276 RVA: 0x00039A90 File Offset: 0x00037C90
		public int GrayHistoRange(HRegion regions, double min, double max, int numBins, out double binSize)
		{
			IntPtr proc = HalconAPI.PreCall(1753);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreD(proc, 0, min);
			HalconAPI.StoreD(proc, 1, max);
			HalconAPI.StoreI(proc, 2, numBins);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out binSize);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the histogram of two-channel gray value images.
		///   Instance represents: Channel 1.
		/// </summary>
		/// <param name="regions">Region in which the histogram is to be calculated.</param>
		/// <param name="imageRow">Channel 2.</param>
		/// <returns>Histogram to be calculated.</returns>
		// Token: 0x060008E5 RID: 2277 RVA: 0x00039B14 File Offset: 0x00037D14
		public HImage Histo2dim(HRegion regions, HImage imageRow)
		{
			IntPtr proc = HalconAPI.PreCall(1754);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 3, imageRow);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			GC.KeepAlive(imageRow);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution.
		///   Instance represents: Image the gray value distribution of which is to be calculated.
		/// </summary>
		/// <param name="regions">Region in which the histogram is to be calculated.</param>
		/// <param name="quantization">Quantization of the gray values. Default: 1.0</param>
		/// <returns>Absolute frequencies of the gray values.</returns>
		// Token: 0x060008E6 RID: 2278 RVA: 0x00039B78 File Offset: 0x00037D78
		public HTuple GrayHistoAbs(HRegion regions, HTuple quantization)
		{
			IntPtr proc = HalconAPI.PreCall(1755);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.Store(proc, 0, quantization);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(quantization);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution.
		///   Instance represents: Image the gray value distribution of which is to be calculated.
		/// </summary>
		/// <param name="regions">Region in which the histogram is to be calculated.</param>
		/// <param name="quantization">Quantization of the gray values. Default: 1.0</param>
		/// <returns>Absolute frequencies of the gray values.</returns>
		// Token: 0x060008E7 RID: 2279 RVA: 0x00039BE0 File Offset: 0x00037DE0
		public HTuple GrayHistoAbs(HRegion regions, double quantization)
		{
			IntPtr proc = HalconAPI.PreCall(1755);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreD(proc, 0, quantization);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the gray value distribution.
		///   Instance represents: Image the gray value distribution of which is to be calculated.
		/// </summary>
		/// <param name="regions">Region in which the histogram is to be calculated.</param>
		/// <param name="relativeHisto">Frequencies, normalized to the area of the region.</param>
		/// <returns>Absolute frequencies of the gray values.</returns>
		// Token: 0x060008E8 RID: 2280 RVA: 0x00039C40 File Offset: 0x00037E40
		public HTuple GrayHisto(HRegion regions, out HTuple relativeHisto)
		{
			IntPtr proc = HalconAPI.PreCall(1756);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out relativeHisto);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Determine the entropy and anisotropy of images.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Regions where the features are to be determined.</param>
		/// <param name="anisotropy">Measure of the symmetry of gray value distribution.</param>
		/// <returns>Information content (entropy) of the gray values.</returns>
		// Token: 0x060008E9 RID: 2281 RVA: 0x00039CAC File Offset: 0x00037EAC
		public HTuple EntropyGray(HRegion regions, out HTuple anisotropy)
		{
			IntPtr proc = HalconAPI.PreCall(1757);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out anisotropy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Determine the entropy and anisotropy of images.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Regions where the features are to be determined.</param>
		/// <param name="anisotropy">Measure of the symmetry of gray value distribution.</param>
		/// <returns>Information content (entropy) of the gray values.</returns>
		// Token: 0x060008EA RID: 2282 RVA: 0x00039D18 File Offset: 0x00037F18
		public double EntropyGray(HRegion regions, out double anisotropy)
		{
			IntPtr proc = HalconAPI.PreCall(1757);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out anisotropy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate gray value features from a co-occurrence matrix.
		///   Instance represents: Co-occurrence matrix.
		/// </summary>
		/// <param name="correlation">Correlation of gray values.</param>
		/// <param name="homogeneity">Local homogeneity of gray values.</param>
		/// <param name="contrast">Gray value contrast.</param>
		/// <returns>Homogeneity of the gray values.</returns>
		// Token: 0x060008EB RID: 2283 RVA: 0x00039D80 File Offset: 0x00037F80
		public double CoocFeatureMatrix(out double correlation, out double homogeneity, out double contrast)
		{
			IntPtr proc = HalconAPI.PreCall(1758);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out correlation);
			num = HalconAPI.LoadD(proc, 2, num, out homogeneity);
			num = HalconAPI.LoadD(proc, 3, num, out contrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate a co-occurrence matrix and derive gray value features thereof.
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Region to be examined.</param>
		/// <param name="ldGray">Number of gray values to be distinguished (2^LdGray@f$2^{LdGray}$). Default: 6</param>
		/// <param name="direction">Direction in which the matrix is to be calculated. Default: 0</param>
		/// <param name="correlation">Correlation of gray values.</param>
		/// <param name="homogeneity">Local homogeneity of gray values.</param>
		/// <param name="contrast">Gray value contrast.</param>
		/// <returns>Gray value energy.</returns>
		// Token: 0x060008EC RID: 2284 RVA: 0x00039E00 File Offset: 0x00038000
		public HTuple CoocFeatureImage(HRegion regions, int ldGray, HTuple direction, out HTuple correlation, out HTuple homogeneity, out HTuple contrast)
		{
			IntPtr proc = HalconAPI.PreCall(1759);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreI(proc, 0, ldGray);
			HalconAPI.Store(proc, 1, direction);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(direction);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out correlation);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out homogeneity);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out contrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate a co-occurrence matrix and derive gray value features thereof.
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Region to be examined.</param>
		/// <param name="ldGray">Number of gray values to be distinguished (2^LdGray@f$2^{LdGray}$). Default: 6</param>
		/// <param name="direction">Direction in which the matrix is to be calculated. Default: 0</param>
		/// <param name="correlation">Correlation of gray values.</param>
		/// <param name="homogeneity">Local homogeneity of gray values.</param>
		/// <param name="contrast">Gray value contrast.</param>
		/// <returns>Gray value energy.</returns>
		// Token: 0x060008ED RID: 2285 RVA: 0x00039EAC File Offset: 0x000380AC
		public double CoocFeatureImage(HRegion regions, int ldGray, int direction, out double correlation, out double homogeneity, out double contrast)
		{
			IntPtr proc = HalconAPI.PreCall(1759);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreI(proc, 0, ldGray);
			HalconAPI.StoreI(proc, 1, direction);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out correlation);
			num = HalconAPI.LoadD(proc, 2, num, out homogeneity);
			num = HalconAPI.LoadD(proc, 3, num, out contrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate the co-occurrence matrix of a region in an image.
		///   Instance represents: Image providing the gray values.
		/// </summary>
		/// <param name="regions">Region to be checked.</param>
		/// <param name="ldGray">Number of gray values to be distinguished (2^LdGray@f$2^{LdGray}$). Default: 6</param>
		/// <param name="direction">Direction of neighbor relation. Default: 0</param>
		/// <returns>Co-occurrence matrix (matrices).</returns>
		// Token: 0x060008EE RID: 2286 RVA: 0x00039F4C File Offset: 0x0003814C
		public HImage GenCoocMatrix(HRegion regions, int ldGray, int direction)
		{
			IntPtr proc = HalconAPI.PreCall(1760);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreI(proc, 0, ldGray);
			HalconAPI.StoreI(proc, 1, direction);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a plane.
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Regions to be checked.</param>
		/// <param name="MRow">Mixed moments along a line.</param>
		/// <param name="MCol">Mixed moments along a column.</param>
		/// <param name="alpha">Parameter Alpha of the approximating plane.</param>
		/// <param name="beta">Parameter Beta of the approximating plane.</param>
		/// <param name="mean">Mean gray value.</param>
		// Token: 0x060008EF RID: 2287 RVA: 0x00039FB4 File Offset: 0x000381B4
		public void MomentsGrayPlane(HRegion regions, out HTuple MRow, out HTuple MCol, out HTuple alpha, out HTuple beta, out HTuple mean)
		{
			IntPtr proc = HalconAPI.PreCall(1761);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out MRow);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out MCol);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out alpha);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out beta);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out mean);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
		}

		/// <summary>
		///   Calculate gray value moments and approximation by a plane.
		///   Instance represents: Corresponding gray values.
		/// </summary>
		/// <param name="regions">Regions to be checked.</param>
		/// <param name="MRow">Mixed moments along a line.</param>
		/// <param name="MCol">Mixed moments along a column.</param>
		/// <param name="alpha">Parameter Alpha of the approximating plane.</param>
		/// <param name="beta">Parameter Beta of the approximating plane.</param>
		/// <param name="mean">Mean gray value.</param>
		// Token: 0x060008F0 RID: 2288 RVA: 0x0003A058 File Offset: 0x00038258
		public void MomentsGrayPlane(HRegion regions, out double MRow, out double MCol, out double alpha, out double beta, out double mean)
		{
			IntPtr proc = HalconAPI.PreCall(1761);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out MRow);
			num = HalconAPI.LoadD(proc, 1, num, out MCol);
			num = HalconAPI.LoadD(proc, 2, num, out alpha);
			num = HalconAPI.LoadD(proc, 3, num, out beta);
			num = HalconAPI.LoadD(proc, 4, num, out mean);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
		}

		/// <summary>
		///   Calculate the deviation of the gray values from the approximating image plane.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Regions, of which the plane deviation is to be calculated.</param>
		/// <returns>Deviation of the gray values within a region.</returns>
		// Token: 0x060008F1 RID: 2289 RVA: 0x0003A0F8 File Offset: 0x000382F8
		public HTuple PlaneDeviation(HRegion regions)
		{
			IntPtr proc = HalconAPI.PreCall(1762);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Compute the orientation and major axes of a region in a gray value image.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Region(s) to be examined.</param>
		/// <param name="rb">Minor axis of the region.</param>
		/// <param name="phi">Angle enclosed by the major axis and the x-axis.</param>
		/// <returns>Major axis of the region.</returns>
		// Token: 0x060008F2 RID: 2290 RVA: 0x0003A150 File Offset: 0x00038350
		public HTuple EllipticAxisGray(HRegion regions, out HTuple rb, out HTuple phi)
		{
			IntPtr proc = HalconAPI.PreCall(1763);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rb);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Compute the orientation and major axes of a region in a gray value image.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Region(s) to be examined.</param>
		/// <param name="rb">Minor axis of the region.</param>
		/// <param name="phi">Angle enclosed by the major axis and the x-axis.</param>
		/// <returns>Major axis of the region.</returns>
		// Token: 0x060008F3 RID: 2291 RVA: 0x0003A1D0 File Offset: 0x000383D0
		public double EllipticAxisGray(HRegion regions, out double rb, out double phi)
		{
			IntPtr proc = HalconAPI.PreCall(1763);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out rb);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Compute the area and center of gravity of a region in a gray value image.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Region(s) to be examined.</param>
		/// <param name="row">Row coordinate of the gray value center of gravity.</param>
		/// <param name="column">Column coordinate of the gray value center of gravity.</param>
		/// <returns>Gray value volume of the region.</returns>
		// Token: 0x060008F4 RID: 2292 RVA: 0x0003A24C File Offset: 0x0003844C
		public HTuple AreaCenterGray(HRegion regions, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1764);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Compute the area and center of gravity of a region in a gray value image.
		///   Instance represents: Gray value image.
		/// </summary>
		/// <param name="regions">Region(s) to be examined.</param>
		/// <param name="row">Row coordinate of the gray value center of gravity.</param>
		/// <param name="column">Column coordinate of the gray value center of gravity.</param>
		/// <returns>Gray value volume of the region.</returns>
		// Token: 0x060008F5 RID: 2293 RVA: 0x0003A2CC File Offset: 0x000384CC
		public double AreaCenterGray(HRegion regions, out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(1764);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out row);
			num = HalconAPI.LoadD(proc, 2, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Calculate horizontal and vertical gray-value projections.
		///   Instance represents: Grayvalues for projections.
		/// </summary>
		/// <param name="region">Region to be processed.</param>
		/// <param name="mode">Method to compute the projections. Default: "simple"</param>
		/// <param name="vertProjection">Vertical projection.</param>
		/// <returns>Horizontal projection.</returns>
		// Token: 0x060008F6 RID: 2294 RVA: 0x0003A348 File Offset: 0x00038548
		public HTuple GrayProjections(HRegion region, string mode, out HTuple vertProjection)
		{
			IntPtr proc = HalconAPI.PreCall(1765);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, region);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out vertProjection);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Detect and read 2D data code symbols in an image or train the 2D data code model.
		///   Instance represents: Input image. If the image has a reduced domain, the data code search is reduced to that domain. This usually reduces the runtime of the operator. However, if the datacode is not fully inside the domain, the datacode might not be found correctly. In rare cases, data codes may be found outside the domain. If these results  are undesirable, they have to be subsequently eliminated. 
		/// </summary>
		/// <param name="dataCodeHandle">Handle of the 2D data code model.</param>
		/// <param name="genParamName">Names of (optional) parameters for controlling the behavior of the operator. Default: []</param>
		/// <param name="genParamValue">Values of the optional generic parameters. Default: []</param>
		/// <param name="resultHandles">Handles of all successfully decoded 2D data code symbols.</param>
		/// <param name="decodedDataStrings">Decoded data strings of all detected 2D data code symbols in the image.</param>
		/// <returns>XLD contours that surround the successfully decoded data code symbols. The order of the contour points reflects the orientation of the detected symbols. The contours begin in the top left corner (see 'orientation' at get_data_code_2d_results) and continue clockwise.  Alignment{left} Figure[1][1][60]{get_data_code_2d_results-xld_qrcode} Order of points of SymbolXLDs Figure Alignment @f$ </returns>
		// Token: 0x060008F7 RID: 2295 RVA: 0x0003A3BC File Offset: 0x000385BC
		public HXLDCont FindDataCode2d(HDataCode2D dataCodeHandle, HTuple genParamName, HTuple genParamValue, out HTuple resultHandles, out HTuple decodedDataStrings)
		{
			IntPtr proc = HalconAPI.PreCall(1768);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, dataCodeHandle);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out resultHandles);
			num = HTuple.LoadNew(proc, 1, num, out decodedDataStrings);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(dataCodeHandle);
			return result;
		}

		/// <summary>
		///   Detect and read 2D data code symbols in an image or train the 2D data code model.
		///   Instance represents: Input image. If the image has a reduced domain, the data code search is reduced to that domain. This usually reduces the runtime of the operator. However, if the datacode is not fully inside the domain, the datacode might not be found correctly. In rare cases, data codes may be found outside the domain. If these results  are undesirable, they have to be subsequently eliminated. 
		/// </summary>
		/// <param name="dataCodeHandle">Handle of the 2D data code model.</param>
		/// <param name="genParamName">Names of (optional) parameters for controlling the behavior of the operator. Default: []</param>
		/// <param name="genParamValue">Values of the optional generic parameters. Default: []</param>
		/// <param name="resultHandles">Handles of all successfully decoded 2D data code symbols.</param>
		/// <param name="decodedDataStrings">Decoded data strings of all detected 2D data code symbols in the image.</param>
		/// <returns>XLD contours that surround the successfully decoded data code symbols. The order of the contour points reflects the orientation of the detected symbols. The contours begin in the top left corner (see 'orientation' at get_data_code_2d_results) and continue clockwise.  Alignment{left} Figure[1][1][60]{get_data_code_2d_results-xld_qrcode} Order of points of SymbolXLDs Figure Alignment @f$ </returns>
		// Token: 0x060008F8 RID: 2296 RVA: 0x0003A458 File Offset: 0x00038658
		public HXLDCont FindDataCode2d(HDataCode2D dataCodeHandle, string genParamName, int genParamValue, out int resultHandles, out string decodedDataStrings)
		{
			IntPtr proc = HalconAPI.PreCall(1768);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, dataCodeHandle);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreI(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HalconAPI.LoadI(proc, 0, num, out resultHandles);
			num = HalconAPI.LoadS(proc, 1, num, out decodedDataStrings);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(dataCodeHandle);
			return result;
		}

		/// <summary>
		///   Convert image maps into other map types.
		///   Instance represents: Input map.
		/// </summary>
		/// <param name="newType">Type of MapConverted. Default: "coord_map_sub_pix"</param>
		/// <param name="imageWidth">Width of images to be mapped. Default: "map_width"</param>
		/// <returns>Converted map.</returns>
		// Token: 0x060008F9 RID: 2297 RVA: 0x0003A4E4 File Offset: 0x000386E4
		public HImage ConvertMapType(string newType, HTuple imageWidth)
		{
			IntPtr proc = HalconAPI.PreCall(1901);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, newType);
			HalconAPI.Store(proc, 1, imageWidth);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(imageWidth);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert image maps into other map types.
		///   Instance represents: Input map.
		/// </summary>
		/// <param name="newType">Type of MapConverted. Default: "coord_map_sub_pix"</param>
		/// <param name="imageWidth">Width of images to be mapped. Default: "map_width"</param>
		/// <returns>Converted map.</returns>
		// Token: 0x060008FA RID: 2298 RVA: 0x0003A544 File Offset: 0x00038744
		public HImage ConvertMapType(string newType, int imageWidth)
		{
			IntPtr proc = HalconAPI.PreCall(1901);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, newType);
			HalconAPI.StoreI(proc, 1, imageWidth);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Compute an absolute pose out of point correspondences between world and image coordinates.</summary>
		/// <param name="worldX">X-Component of world coordinates.</param>
		/// <param name="worldY">Y-Component of world coordinates.</param>
		/// <param name="worldZ">Z-Component of world coordinates.</param>
		/// <param name="imageRow">Row-Component of image coordinates.</param>
		/// <param name="imageColumn">Column-Component of image coordinates.</param>
		/// <param name="cameraParam">The inner camera parameters from camera calibration.</param>
		/// <param name="method">Kind of algorithm Default: "iterative"</param>
		/// <param name="qualityType">Type of pose quality to be returned in Quality. Default: "error"</param>
		/// <param name="quality">Pose quality.</param>
		/// <returns>Pose.</returns>
		// Token: 0x060008FB RID: 2299 RVA: 0x0003A59C File Offset: 0x0003879C
		public static HPose VectorToPose(HTuple worldX, HTuple worldY, HTuple worldZ, HTuple imageRow, HTuple imageColumn, HCamPar cameraParam, string method, HTuple qualityType, out HTuple quality)
		{
			IntPtr proc = HalconAPI.PreCall(1902);
			HalconAPI.Store(proc, 0, worldX);
			HalconAPI.Store(proc, 1, worldY);
			HalconAPI.Store(proc, 2, worldZ);
			HalconAPI.Store(proc, 3, imageRow);
			HalconAPI.Store(proc, 4, imageColumn);
			HalconAPI.Store(proc, 5, cameraParam);
			HalconAPI.StoreS(proc, 6, method);
			HalconAPI.Store(proc, 7, qualityType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(worldX);
			HalconAPI.UnpinTuple(worldY);
			HalconAPI.UnpinTuple(worldZ);
			HalconAPI.UnpinTuple(imageRow);
			HalconAPI.UnpinTuple(imageColumn);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(qualityType);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out quality);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Compute an absolute pose out of point correspondences between world and image coordinates.</summary>
		/// <param name="worldX">X-Component of world coordinates.</param>
		/// <param name="worldY">Y-Component of world coordinates.</param>
		/// <param name="worldZ">Z-Component of world coordinates.</param>
		/// <param name="imageRow">Row-Component of image coordinates.</param>
		/// <param name="imageColumn">Column-Component of image coordinates.</param>
		/// <param name="cameraParam">The inner camera parameters from camera calibration.</param>
		/// <param name="method">Kind of algorithm Default: "iterative"</param>
		/// <param name="qualityType">Type of pose quality to be returned in Quality. Default: "error"</param>
		/// <param name="quality">Pose quality.</param>
		/// <returns>Pose.</returns>
		// Token: 0x060008FC RID: 2300 RVA: 0x0003A664 File Offset: 0x00038864
		public static HPose VectorToPose(HTuple worldX, HTuple worldY, HTuple worldZ, HTuple imageRow, HTuple imageColumn, HCamPar cameraParam, string method, string qualityType, out double quality)
		{
			IntPtr proc = HalconAPI.PreCall(1902);
			HalconAPI.Store(proc, 0, worldX);
			HalconAPI.Store(proc, 1, worldY);
			HalconAPI.Store(proc, 2, worldZ);
			HalconAPI.Store(proc, 3, imageRow);
			HalconAPI.Store(proc, 4, imageColumn);
			HalconAPI.Store(proc, 5, cameraParam);
			HalconAPI.StoreS(proc, 6, method);
			HalconAPI.StoreS(proc, 7, qualityType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(worldX);
			HalconAPI.UnpinTuple(worldY);
			HalconAPI.UnpinTuple(worldZ);
			HalconAPI.UnpinTuple(imageRow);
			HalconAPI.UnpinTuple(imageColumn);
			HalconAPI.UnpinTuple(cameraParam);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out quality);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Compute a pose out of a homography describing the relation between world and image coordinates.</summary>
		/// <param name="homography">The homography from world- to image coordinates.</param>
		/// <param name="cameraMatrix">The camera calibration matrix K.</param>
		/// <param name="method">Type of pose computation. Default: "decomposition"</param>
		/// <returns>Pose of the 2D object.</returns>
		// Token: 0x060008FD RID: 2301 RVA: 0x0003A724 File Offset: 0x00038924
		public static HPose ProjHomMat2dToPose(HHomMat2D homography, HHomMat2D cameraMatrix, string method)
		{
			IntPtr proc = HalconAPI.PreCall(1903);
			HalconAPI.Store(proc, 0, homography);
			HalconAPI.Store(proc, 1, cameraMatrix);
			HalconAPI.StoreS(proc, 2, method);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homography);
			HalconAPI.UnpinTuple(cameraMatrix);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>
		///   Perform a radiometric self-calibration of a camera.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="exposureRatios">Ratio of the exposure energies of successive image pairs. Default: 0.5</param>
		/// <param name="features">Features that are used to compute the inverse response function of the camera. Default: "2d_histogram"</param>
		/// <param name="functionType">Type of the inverse response function of the camera. Default: "discrete"</param>
		/// <param name="smoothness">Smoothness of the inverse response function of the camera. Default: 1.0</param>
		/// <param name="polynomialDegree">Degree of the polynomial if FunctionType = 'polynomial'. Default: 5</param>
		/// <returns>Inverse response function of the camera.</returns>
		// Token: 0x060008FE RID: 2302 RVA: 0x0003A794 File Offset: 0x00038994
		public HTuple RadiometricSelfCalibration(HTuple exposureRatios, string features, string functionType, double smoothness, int polynomialDegree)
		{
			IntPtr proc = HalconAPI.PreCall(1910);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, exposureRatios);
			HalconAPI.StoreS(proc, 1, features);
			HalconAPI.StoreS(proc, 2, functionType);
			HalconAPI.StoreD(proc, 3, smoothness);
			HalconAPI.StoreI(proc, 4, polynomialDegree);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(exposureRatios);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Perform a radiometric self-calibration of a camera.
		///   Instance represents: Input images.
		/// </summary>
		/// <param name="exposureRatios">Ratio of the exposure energies of successive image pairs. Default: 0.5</param>
		/// <param name="features">Features that are used to compute the inverse response function of the camera. Default: "2d_histogram"</param>
		/// <param name="functionType">Type of the inverse response function of the camera. Default: "discrete"</param>
		/// <param name="smoothness">Smoothness of the inverse response function of the camera. Default: 1.0</param>
		/// <param name="polynomialDegree">Degree of the polynomial if FunctionType = 'polynomial'. Default: 5</param>
		/// <returns>Inverse response function of the camera.</returns>
		// Token: 0x060008FF RID: 2303 RVA: 0x0003A80C File Offset: 0x00038A0C
		public HTuple RadiometricSelfCalibration(double exposureRatios, string features, string functionType, double smoothness, int polynomialDegree)
		{
			IntPtr proc = HalconAPI.PreCall(1910);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, exposureRatios);
			HalconAPI.StoreS(proc, 1, features);
			HalconAPI.StoreS(proc, 2, functionType);
			HalconAPI.StoreD(proc, 3, smoothness);
			HalconAPI.StoreI(proc, 4, polynomialDegree);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply a general transformation to an image.
		///   Instance represents: Image to be mapped.
		/// </summary>
		/// <param name="map">Image containing the mapping data.</param>
		/// <returns>Mapped image.</returns>
		// Token: 0x06000900 RID: 2304 RVA: 0x0003A880 File Offset: 0x00038A80
		public HImage MapImage(HImage map)
		{
			IntPtr proc = HalconAPI.PreCall(1911);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, map);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(map);
			return result;
		}

		/// <summary>
		///   Generate a projection map that describes the mapping of images corresponding to a changing radial distortion.
		///   Modified instance represents: Image containing the mapping data.
		/// </summary>
		/// <param name="camParamIn">Old camera parameters.</param>
		/// <param name="camParamOut">New camera parameters.</param>
		/// <param name="mapType">Type of the mapping. Default: "bilinear"</param>
		// Token: 0x06000901 RID: 2305 RVA: 0x0003A8D8 File Offset: 0x00038AD8
		public void GenRadialDistortionMap(HCamPar camParamIn, HCamPar camParamOut, string mapType)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1912);
			HalconAPI.Store(proc, 0, camParamIn);
			HalconAPI.Store(proc, 1, camParamOut);
			HalconAPI.StoreS(proc, 2, mapType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamIn);
			HalconAPI.UnpinTuple(camParamOut);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate a projection map that describes the mapping between the image plane and a the plane z=0 of a world coordinate system.
		///   Modified instance represents: Image containing the mapping data.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="worldPose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="widthIn">Width of the images to be transformed.</param>
		/// <param name="heightIn">Height of the images to be transformed.</param>
		/// <param name="widthMapped">Width of the resulting mapped images in pixels.</param>
		/// <param name="heightMapped">Height of the resulting mapped images in pixels.</param>
		/// <param name="scale">Scale or unit. Default: "m"</param>
		/// <param name="mapType">Type of the mapping. Default: "bilinear"</param>
		// Token: 0x06000902 RID: 2306 RVA: 0x0003A954 File Offset: 0x00038B54
		public void GenImageToWorldPlaneMap(HCamPar cameraParam, HPose worldPose, int widthIn, int heightIn, int widthMapped, int heightMapped, HTuple scale, string mapType)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1913);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, worldPose);
			HalconAPI.StoreI(proc, 2, widthIn);
			HalconAPI.StoreI(proc, 3, heightIn);
			HalconAPI.StoreI(proc, 4, widthMapped);
			HalconAPI.StoreI(proc, 5, heightMapped);
			HalconAPI.Store(proc, 6, scale);
			HalconAPI.StoreS(proc, 7, mapType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(worldPose);
			HalconAPI.UnpinTuple(scale);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate a projection map that describes the mapping between the image plane and a the plane z=0 of a world coordinate system.
		///   Modified instance represents: Image containing the mapping data.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="worldPose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="widthIn">Width of the images to be transformed.</param>
		/// <param name="heightIn">Height of the images to be transformed.</param>
		/// <param name="widthMapped">Width of the resulting mapped images in pixels.</param>
		/// <param name="heightMapped">Height of the resulting mapped images in pixels.</param>
		/// <param name="scale">Scale or unit. Default: "m"</param>
		/// <param name="mapType">Type of the mapping. Default: "bilinear"</param>
		// Token: 0x06000903 RID: 2307 RVA: 0x0003AA04 File Offset: 0x00038C04
		public void GenImageToWorldPlaneMap(HCamPar cameraParam, HPose worldPose, int widthIn, int heightIn, int widthMapped, int heightMapped, string scale, string mapType)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1913);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, worldPose);
			HalconAPI.StoreI(proc, 2, widthIn);
			HalconAPI.StoreI(proc, 3, heightIn);
			HalconAPI.StoreI(proc, 4, widthMapped);
			HalconAPI.StoreI(proc, 5, heightMapped);
			HalconAPI.StoreS(proc, 6, scale);
			HalconAPI.StoreS(proc, 7, mapType);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(worldPose);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Rectify an image by transforming it into the plane z=0 of a world coordinate system.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="worldPose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="width">Width of the resulting image in pixels.</param>
		/// <param name="height">Height of the resulting image in pixels.</param>
		/// <param name="scale">Scale or unit Default: "m"</param>
		/// <param name="interpolation">Type of interpolation. Default: "bilinear"</param>
		/// <returns>Transformed image.</returns>
		// Token: 0x06000904 RID: 2308 RVA: 0x0003AAB0 File Offset: 0x00038CB0
		public HImage ImageToWorldPlane(HCamPar cameraParam, HPose worldPose, int width, int height, HTuple scale, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1914);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, worldPose);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.Store(proc, 4, scale);
			HalconAPI.StoreS(proc, 5, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(worldPose);
			HalconAPI.UnpinTuple(scale);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Rectify an image by transforming it into the plane z=0 of a world coordinate system.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="worldPose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="width">Width of the resulting image in pixels.</param>
		/// <param name="height">Height of the resulting image in pixels.</param>
		/// <param name="scale">Scale or unit Default: "m"</param>
		/// <param name="interpolation">Type of interpolation. Default: "bilinear"</param>
		/// <returns>Transformed image.</returns>
		// Token: 0x06000905 RID: 2309 RVA: 0x0003AB54 File Offset: 0x00038D54
		public HImage ImageToWorldPlane(HCamPar cameraParam, HPose worldPose, int width, int height, string scale, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(1914);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, worldPose);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.StoreS(proc, 4, scale);
			HalconAPI.StoreS(proc, 5, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(worldPose);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Change the radial distortion of an image.
		///   Instance represents: Original image.
		/// </summary>
		/// <param name="region">Region of interest in ImageRectified.</param>
		/// <param name="camParamIn">Internal camera parameter for Image.</param>
		/// <param name="camParamOut">Internal camera parameter for Image.</param>
		/// <returns>Resulting image with modified radial distortion.</returns>
		// Token: 0x06000906 RID: 2310 RVA: 0x0003ABF0 File Offset: 0x00038DF0
		public HImage ChangeRadialDistortionImage(HRegion region, HCamPar camParamIn, HCamPar camParamOut)
		{
			IntPtr proc = HalconAPI.PreCall(1924);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, region);
			HalconAPI.Store(proc, 0, camParamIn);
			HalconAPI.Store(proc, 1, camParamOut);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamIn);
			HalconAPI.UnpinTuple(camParamOut);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Simulate an image with calibration plate.
		///   Modified instance represents: Simulated calibration image.
		/// </summary>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "calplate_320mm.cpd"</param>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="calPlatePose">External camera parameters (3D pose of the calibration plate in camera coordinates).</param>
		/// <param name="grayBackground">Gray value of image background. Default: 128</param>
		/// <param name="grayPlate">Gray value of calibration plate. Default: 80</param>
		/// <param name="grayMarks">Gray value of calibration marks. Default: 224</param>
		/// <param name="scaleFac">Scaling factor to reduce oversampling. Default: 1.0</param>
		// Token: 0x06000907 RID: 2311 RVA: 0x0003AC78 File Offset: 0x00038E78
		public void SimCaltab(string calPlateDescr, HCamPar cameraParam, HPose calPlatePose, int grayBackground, int grayPlate, int grayMarks, double scaleFac)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1944);
			HalconAPI.StoreS(proc, 0, calPlateDescr);
			HalconAPI.Store(proc, 1, cameraParam);
			HalconAPI.Store(proc, 2, calPlatePose);
			HalconAPI.StoreI(proc, 3, grayBackground);
			HalconAPI.StoreI(proc, 4, grayPlate);
			HalconAPI.StoreI(proc, 5, grayMarks);
			HalconAPI.StoreD(proc, 6, scaleFac);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(calPlatePose);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Extract rectangularly arranged 2D calibration marks from the image and calculate initial values for the external camera parameters.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="calPlateRegion">Region of the calibration plate.</param>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "caltab_100.descr"</param>
		/// <param name="startCamParam">Initial values for the internal camera parameters.</param>
		/// <param name="startThresh">Initial threshold value for contour detection. Default: 128</param>
		/// <param name="deltaThresh">Loop value for successive reduction of StartThresh. Default: 10</param>
		/// <param name="minThresh">Minimum threshold for contour detection. Default: 18</param>
		/// <param name="alpha">Filter parameter for contour detection, see edges_image. Default: 0.9</param>
		/// <param name="minContLength">Minimum length of the contours of the marks. Default: 15.0</param>
		/// <param name="maxDiamMarks">Maximum expected diameter of the marks. Default: 100.0</param>
		/// <param name="CCoord">Tuple with column coordinates of the detected marks.</param>
		/// <param name="startPose">Estimation for the external camera parameters.</param>
		/// <returns>Tuple with row coordinates of the detected marks.</returns>
		// Token: 0x06000908 RID: 2312 RVA: 0x0003AD18 File Offset: 0x00038F18
		public HTuple FindMarksAndPose(HRegion calPlateRegion, string calPlateDescr, HCamPar startCamParam, int startThresh, int deltaThresh, int minThresh, double alpha, double minContLength, double maxDiamMarks, out HTuple CCoord, out HPose startPose)
		{
			IntPtr proc = HalconAPI.PreCall(1947);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, calPlateRegion);
			HalconAPI.StoreS(proc, 0, calPlateDescr);
			HalconAPI.Store(proc, 1, startCamParam);
			HalconAPI.StoreI(proc, 2, startThresh);
			HalconAPI.StoreI(proc, 3, deltaThresh);
			HalconAPI.StoreI(proc, 4, minThresh);
			HalconAPI.StoreD(proc, 5, alpha);
			HalconAPI.StoreD(proc, 6, minContLength);
			HalconAPI.StoreD(proc, 7, maxDiamMarks);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(startCamParam);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out CCoord);
			num = HPose.LoadNew(proc, 2, num, out startPose);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(calPlateRegion);
			return result;
		}

		/// <summary>
		///   Segment the region of a standard calibration plate with rectangularly arranged marks in the image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "caltab_100.descr"</param>
		/// <param name="sizeGauss">Filter size of the Gaussian. Default: 3</param>
		/// <param name="markThresh">Threshold value for mark extraction. Default: 112</param>
		/// <param name="minDiamMarks">Expected minimal diameter of the marks on the calibration plate. Default: 5</param>
		/// <returns>Output region.</returns>
		// Token: 0x06000909 RID: 2313 RVA: 0x0003ADEC File Offset: 0x00038FEC
		public HRegion FindCaltab(string calPlateDescr, HTuple sizeGauss, HTuple markThresh, int minDiamMarks)
		{
			IntPtr proc = HalconAPI.PreCall(1948);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, calPlateDescr);
			HalconAPI.Store(proc, 1, sizeGauss);
			HalconAPI.Store(proc, 2, markThresh);
			HalconAPI.StoreI(proc, 3, minDiamMarks);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(sizeGauss);
			HalconAPI.UnpinTuple(markThresh);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment the region of a standard calibration plate with rectangularly arranged marks in the image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "caltab_100.descr"</param>
		/// <param name="sizeGauss">Filter size of the Gaussian. Default: 3</param>
		/// <param name="markThresh">Threshold value for mark extraction. Default: 112</param>
		/// <param name="minDiamMarks">Expected minimal diameter of the marks on the calibration plate. Default: 5</param>
		/// <returns>Output region.</returns>
		// Token: 0x0600090A RID: 2314 RVA: 0x0003AE64 File Offset: 0x00039064
		public HRegion FindCaltab(string calPlateDescr, int sizeGauss, int markThresh, int minDiamMarks)
		{
			IntPtr proc = HalconAPI.PreCall(1948);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, calPlateDescr);
			HalconAPI.StoreI(proc, 1, sizeGauss);
			HalconAPI.StoreI(proc, 2, markThresh);
			HalconAPI.StoreI(proc, 3, minDiamMarks);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Decode bar code symbols within a rectangle.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="barCodeHandle">Handle of the bar code model.</param>
		/// <param name="codeType">Type of the searched bar code. Default: "EAN-13"</param>
		/// <param name="row">Row index of the center. Default: 50.0</param>
		/// <param name="column">Column index of the center. Default: 100.0</param>
		/// <param name="phi">Orientation of rectangle in radians. Default: 0.0</param>
		/// <param name="length1">Half of the length of the rectangle along the reading direction of the bar code. Default: 200.0</param>
		/// <param name="length2">Half of the length of the rectangle perpendicular to the reading direction of the bar code. Default: 100.0</param>
		/// <returns>Data strings of all successfully decoded bar codes.</returns>
		// Token: 0x0600090B RID: 2315 RVA: 0x0003AED0 File Offset: 0x000390D0
		public HTuple DecodeBarCodeRectangle2(HBarCode barCodeHandle, HTuple codeType, HTuple row, HTuple column, HTuple phi, HTuple length1, HTuple length2)
		{
			IntPtr proc = HalconAPI.PreCall(1992);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, barCodeHandle);
			HalconAPI.Store(proc, 1, codeType);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.Store(proc, 4, phi);
			HalconAPI.Store(proc, 5, length1);
			HalconAPI.Store(proc, 6, length2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(codeType);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(length1);
			HalconAPI.UnpinTuple(length2);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(barCodeHandle);
			return result;
		}

		/// <summary>
		///   Decode bar code symbols within a rectangle.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="barCodeHandle">Handle of the bar code model.</param>
		/// <param name="codeType">Type of the searched bar code. Default: "EAN-13"</param>
		/// <param name="row">Row index of the center. Default: 50.0</param>
		/// <param name="column">Column index of the center. Default: 100.0</param>
		/// <param name="phi">Orientation of rectangle in radians. Default: 0.0</param>
		/// <param name="length1">Half of the length of the rectangle along the reading direction of the bar code. Default: 200.0</param>
		/// <param name="length2">Half of the length of the rectangle perpendicular to the reading direction of the bar code. Default: 100.0</param>
		/// <returns>Data strings of all successfully decoded bar codes.</returns>
		// Token: 0x0600090C RID: 2316 RVA: 0x0003AF84 File Offset: 0x00039184
		public string DecodeBarCodeRectangle2(HBarCode barCodeHandle, string codeType, double row, double column, double phi, double length1, double length2)
		{
			IntPtr proc = HalconAPI.PreCall(1992);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, barCodeHandle);
			HalconAPI.StoreS(proc, 1, codeType);
			HalconAPI.StoreD(proc, 2, row);
			HalconAPI.StoreD(proc, 3, column);
			HalconAPI.StoreD(proc, 4, phi);
			HalconAPI.StoreD(proc, 5, length1);
			HalconAPI.StoreD(proc, 6, length2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(barCodeHandle);
			return result;
		}

		/// <summary>
		///   Detect and read bar code symbols in an image.
		///   Instance represents: Input image. If the image has a reduced domain, the bar code search is reduced to that domain. This usually reduces the runtime of the operator. However, if the bar code is not fully inside the domain, the bar code cannot be decoded correctly.
		/// </summary>
		/// <param name="barCodeHandle">Handle of the bar code model.</param>
		/// <param name="codeType">Type of the searched bar code. Default: "auto"</param>
		/// <param name="decodedDataStrings">Data strings of all successfully decoded bar codes.</param>
		/// <returns>Regions of the successfully decoded bar code symbols.</returns>
		// Token: 0x0600090D RID: 2317 RVA: 0x0003B010 File Offset: 0x00039210
		public HRegion FindBarCode(HBarCode barCodeHandle, HTuple codeType, out HTuple decodedDataStrings)
		{
			IntPtr proc = HalconAPI.PreCall(1993);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, barCodeHandle);
			HalconAPI.Store(proc, 1, codeType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(codeType);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, num, out decodedDataStrings);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(barCodeHandle);
			return result;
		}

		/// <summary>
		///   Detect and read bar code symbols in an image.
		///   Instance represents: Input image. If the image has a reduced domain, the bar code search is reduced to that domain. This usually reduces the runtime of the operator. However, if the bar code is not fully inside the domain, the bar code cannot be decoded correctly.
		/// </summary>
		/// <param name="barCodeHandle">Handle of the bar code model.</param>
		/// <param name="codeType">Type of the searched bar code. Default: "auto"</param>
		/// <param name="decodedDataStrings">Data strings of all successfully decoded bar codes.</param>
		/// <returns>Regions of the successfully decoded bar code symbols.</returns>
		// Token: 0x0600090E RID: 2318 RVA: 0x0003B088 File Offset: 0x00039288
		public HRegion FindBarCode(HBarCode barCodeHandle, string codeType, out string decodedDataStrings)
		{
			IntPtr proc = HalconAPI.PreCall(1993);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, barCodeHandle);
			HalconAPI.StoreS(proc, 1, codeType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HalconAPI.LoadS(proc, 0, num, out decodedDataStrings);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(barCodeHandle);
			return result;
		}

		/// <summary>
		///   Return the estimated background image.
		///   Modified instance represents: Estimated background image of the current data set.
		/// </summary>
		/// <param name="bgEstiHandle">ID of the BgEsti data set.</param>
		// Token: 0x0600090F RID: 2319 RVA: 0x0003B0F8 File Offset: 0x000392F8
		public void GiveBgEsti(HBgEsti bgEstiHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2003);
			HalconAPI.Store(proc, 0, bgEstiHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(bgEstiHandle);
		}

		/// <summary>
		///   Change the estimated background image.
		///   Instance represents: Current image.
		/// </summary>
		/// <param name="upDateRegion">Region describing areas to change.</param>
		/// <param name="bgEstiHandle">ID of the BgEsti data set.</param>
		// Token: 0x06000910 RID: 2320 RVA: 0x0003B14C File Offset: 0x0003934C
		public void UpdateBgEsti(HRegion upDateRegion, HBgEsti bgEstiHandle)
		{
			IntPtr proc = HalconAPI.PreCall(2004);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, upDateRegion);
			HalconAPI.Store(proc, 0, bgEstiHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(upDateRegion);
			GC.KeepAlive(bgEstiHandle);
		}

		/// <summary>
		///   Estimate the background and return the foreground region.
		///   Instance represents: Current image.
		/// </summary>
		/// <param name="bgEstiHandle">ID of the BgEsti data set.</param>
		/// <returns>Region of the detected foreground.</returns>
		// Token: 0x06000911 RID: 2321 RVA: 0x0003B19C File Offset: 0x0003939C
		public HRegion RunBgEsti(HBgEsti bgEstiHandle)
		{
			IntPtr proc = HalconAPI.PreCall(2005);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, bgEstiHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(bgEstiHandle);
			return result;
		}

		/// <summary>
		///   Generate and initialize a data set for the background estimation.
		///   Instance represents: initialization image.
		/// </summary>
		/// <param name="syspar1">1. system matrix parameter. Default: 0.7</param>
		/// <param name="syspar2">2. system matrix parameter. Default: 0.7</param>
		/// <param name="gainMode">Gain type. Default: "fixed"</param>
		/// <param name="gain1">Kalman gain / foreground adaptation time. Default: 0.002</param>
		/// <param name="gain2">Kalman gain / background adaptation time. Default: 0.02</param>
		/// <param name="adaptMode">Threshold adaptation. Default: "on"</param>
		/// <param name="minDiff">Foreground/background threshold. Default: 7.0</param>
		/// <param name="statNum">Number of statistic data sets. Default: 10</param>
		/// <param name="confidenceC">Confidence constant. Default: 3.25</param>
		/// <param name="timeC">Constant for decay time. Default: 15.0</param>
		/// <returns>ID of the BgEsti data set.</returns>
		// Token: 0x06000912 RID: 2322 RVA: 0x0003B1F4 File Offset: 0x000393F4
		public HBgEsti CreateBgEsti(double syspar1, double syspar2, string gainMode, double gain1, double gain2, string adaptMode, double minDiff, int statNum, double confidenceC, double timeC)
		{
			IntPtr proc = HalconAPI.PreCall(2008);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, syspar1);
			HalconAPI.StoreD(proc, 1, syspar2);
			HalconAPI.StoreS(proc, 2, gainMode);
			HalconAPI.StoreD(proc, 3, gain1);
			HalconAPI.StoreD(proc, 4, gain2);
			HalconAPI.StoreS(proc, 5, adaptMode);
			HalconAPI.StoreD(proc, 6, minDiff);
			HalconAPI.StoreI(proc, 7, statNum);
			HalconAPI.StoreD(proc, 8, confidenceC);
			HalconAPI.StoreD(proc, 9, timeC);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HBgEsti result;
			num = HBgEsti.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Asynchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Grabbed image data.
		/// </summary>
		/// <param name="contours">Pre-processed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="maxDelay">Maximum tolerated delay between the start of the asynchronous grab and the delivery of the image [ms]. Default: -1.0</param>
		/// <param name="data">Pre-processed control data.</param>
		/// <returns>Pre-processed image regions.</returns>
		// Token: 0x06000913 RID: 2323 RVA: 0x0003B294 File Offset: 0x00039494
		public HRegion GrabDataAsync(out HXLDCont contours, HFramegrabber acqHandle, double maxDelay, out HTuple data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2029);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.StoreD(proc, 1, maxDelay);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HRegion result;
			num = HRegion.LoadNew(proc, 2, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HTuple.LoadNew(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Asynchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Grabbed image data.
		/// </summary>
		/// <param name="contours">Pre-processed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="maxDelay">Maximum tolerated delay between the start of the asynchronous grab and the delivery of the image [ms]. Default: -1.0</param>
		/// <param name="data">Pre-processed control data.</param>
		/// <returns>Pre-processed image regions.</returns>
		// Token: 0x06000914 RID: 2324 RVA: 0x0003B328 File Offset: 0x00039528
		public HRegion GrabDataAsync(out HXLDCont contours, HFramegrabber acqHandle, double maxDelay, out string data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2029);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.StoreD(proc, 1, maxDelay);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HRegion result;
			num = HRegion.LoadNew(proc, 2, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HalconAPI.LoadS(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Synchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Grabbed image data.
		/// </summary>
		/// <param name="contours">Preprocessed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="data">Preprocessed control data.</param>
		/// <returns>Preprocessed image regions.</returns>
		// Token: 0x06000915 RID: 2325 RVA: 0x0003B3BC File Offset: 0x000395BC
		public HRegion GrabData(out HXLDCont contours, HFramegrabber acqHandle, out HTuple data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2030);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HRegion result;
			num = HRegion.LoadNew(proc, 2, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HTuple.LoadNew(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Synchronous grab of images and preprocessed image data from the specified image acquisition device.
		///   Modified instance represents: Grabbed image data.
		/// </summary>
		/// <param name="contours">Preprocessed XLD contours.</param>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="data">Preprocessed control data.</param>
		/// <returns>Preprocessed image regions.</returns>
		// Token: 0x06000916 RID: 2326 RVA: 0x0003B448 File Offset: 0x00039648
		public HRegion GrabData(out HXLDCont contours, HFramegrabber acqHandle, out string data)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2030);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HRegion result;
			num = HRegion.LoadNew(proc, 2, num, out result);
			num = HXLDCont.LoadNew(proc, 3, num, out contours);
			num = HalconAPI.LoadS(proc, 0, num, out data);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
			return result;
		}

		/// <summary>
		///   Asynchronous grab of an image from the specified image acquisition device.
		///   Modified instance represents: Grabbed image.
		/// </summary>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		/// <param name="maxDelay">Maximum tolerated delay between the start of the asynchronous grab and the delivery of the image [ms]. Default: -1.0</param>
		// Token: 0x06000917 RID: 2327 RVA: 0x0003B4D4 File Offset: 0x000396D4
		public void GrabImageAsync(HFramegrabber acqHandle, double maxDelay)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2031);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.StoreD(proc, 1, maxDelay);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
		}

		/// <summary>
		///   Synchronous grab of an image from the specified image acquisition device.
		///   Modified instance represents: Grabbed image.
		/// </summary>
		/// <param name="acqHandle">Handle of the acquisition device to be used.</param>
		// Token: 0x06000918 RID: 2328 RVA: 0x0003B530 File Offset: 0x00039730
		public void GrabImage(HFramegrabber acqHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2033);
			HalconAPI.Store(proc, 0, acqHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(acqHandle);
		}

		/// <summary>
		///   Add training images to the texture inspection model.
		///   Instance represents: Image of flawless texture.
		/// </summary>
		/// <param name="textureInspectionModel">Handle of the texture inspection model.</param>
		/// <returns>Indices of the images that have been added to the texture inspection model.</returns>
		// Token: 0x06000919 RID: 2329 RVA: 0x0003B584 File Offset: 0x00039784
		public HTuple AddTextureInspectionModelImage(HTextureInspectionModel textureInspectionModel)
		{
			IntPtr proc = HalconAPI.PreCall(2043);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, textureInspectionModel);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(textureInspectionModel);
			return result;
		}

		/// <summary>
		///   Inspection of the texture within an image.
		///   Instance represents: Image of the texture to be inspected.
		/// </summary>
		/// <param name="textureInspectionModel">Handle of the texture inspection model.</param>
		/// <param name="textureInspectionResultID">Handle of the inspection results.</param>
		/// <returns>Novelty regions.</returns>
		// Token: 0x0600091A RID: 2330 RVA: 0x0003B5DC File Offset: 0x000397DC
		public HRegion ApplyTextureInspectionModel(HTextureInspectionModel textureInspectionModel, out HTextureInspectionResult textureInspectionResultID)
		{
			IntPtr proc = HalconAPI.PreCall(2044);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, textureInspectionModel);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HTextureInspectionResult.LoadNew(proc, 0, num, out textureInspectionResultID);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(textureInspectionModel);
			return result;
		}

		/// <summary>
		///   bilateral filtering of an image.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="imageJoint">Joint image.</param>
		/// <param name="sigmaSpatial">Size of the Gaussian of the closeness function. Default: 3.0</param>
		/// <param name="sigmaRange">Size of the Gaussian of the similarity function. Default: 20.0</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <returns>Filtered output image.</returns>
		// Token: 0x0600091B RID: 2331 RVA: 0x0003B644 File Offset: 0x00039844
		public HImage BilateralFilter(HImage imageJoint, double sigmaSpatial, double sigmaRange, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2045);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageJoint);
			HalconAPI.StoreD(proc, 0, sigmaSpatial);
			HalconAPI.StoreD(proc, 1, sigmaRange);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageJoint);
			return result;
		}

		/// <summary>
		///   bilateral filtering of an image.
		///   Instance represents: Image to be filtered.
		/// </summary>
		/// <param name="imageJoint">Joint image.</param>
		/// <param name="sigmaSpatial">Size of the Gaussian of the closeness function. Default: 3.0</param>
		/// <param name="sigmaRange">Size of the Gaussian of the similarity function. Default: 20.0</param>
		/// <param name="genParamName">Generic parameter name. Default: []</param>
		/// <param name="genParamValue">Generic parameter value. Default: []</param>
		/// <returns>Filtered output image.</returns>
		// Token: 0x0600091C RID: 2332 RVA: 0x0003B6CC File Offset: 0x000398CC
		public HImage BilateralFilter(HImage imageJoint, double sigmaSpatial, double sigmaRange, string genParamName, double genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2045);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageJoint);
			HalconAPI.StoreD(proc, 0, sigmaSpatial);
			HalconAPI.StoreD(proc, 1, sigmaRange);
			HalconAPI.StoreS(proc, 2, genParamName);
			HalconAPI.StoreD(proc, 3, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageJoint);
			return result;
		}

		/// <summary>
		///   Find the best matches of multiple NCC models.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.8</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "true"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x0600091D RID: 2333 RVA: 0x0003B744 File Offset: 0x00039944
		public void FindNccModels(HNCCModel[] modelIDs, HTuple angleStart, HTuple angleExtent, HTuple minScore, HTuple numMatches, HTuple maxOverlap, HTuple subPixel, HTuple numLevels, out HTuple row, out HTuple column, out HTuple angle, out HTuple score, out HTuple model)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelIDs);
			IntPtr proc = HalconAPI.PreCall(2068);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, htuple);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, minScore);
			HalconAPI.Store(proc, 4, numMatches);
			HalconAPI.Store(proc, 5, maxOverlap);
			HalconAPI.Store(proc, 6, subPixel);
			HalconAPI.Store(proc, 7, numLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(minScore);
			HalconAPI.UnpinTuple(numMatches);
			HalconAPI.UnpinTuple(maxOverlap);
			HalconAPI.UnpinTuple(subPixel);
			HalconAPI.UnpinTuple(numLevels);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Find the best matches of multiple NCC models.
		///   Instance represents: Input image in which the model should be found.
		/// </summary>
		/// <param name="modelIDs">Handle of the models.</param>
		/// <param name="angleStart">Smallest rotation of the models. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="minScore">Minimum score of the instances of the models to be found. Default: 0.8</param>
		/// <param name="numMatches">Number of instances of the models to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the models to be found. Default: 0.5</param>
		/// <param name="subPixel">Subpixel accuracy if not equal to 'none'. Default: "true"</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="row">Row coordinate of the found instances of the models.</param>
		/// <param name="column">Column coordinate of the found instances of the models.</param>
		/// <param name="angle">Rotation angle of the found instances of the models.</param>
		/// <param name="score">Score of the found instances of the models.</param>
		/// <param name="model">Index of the found instances of the models.</param>
		// Token: 0x0600091E RID: 2334 RVA: 0x0003B868 File Offset: 0x00039A68
		public void FindNccModels(HNCCModel modelIDs, double angleStart, double angleExtent, double minScore, int numMatches, double maxOverlap, string subPixel, int numLevels, out HTuple row, out HTuple column, out HTuple angle, out HTuple score, out HTuple model)
		{
			IntPtr proc = HalconAPI.PreCall(2068);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, modelIDs);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, minScore);
			HalconAPI.StoreI(proc, 4, numMatches);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, subPixel);
			HalconAPI.StoreI(proc, 7, numLevels);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out angle);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out model);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(modelIDs);
		}

		/// <summary>
		///   Get the training images contained in a texture inspection model.
		///   Modified instance represents: Training images contained in the texture inspection model.
		/// </summary>
		/// <param name="textureInspectionModel">Handle of the texture inspection model.</param>
		// Token: 0x0600091F RID: 2335 RVA: 0x0003B94C File Offset: 0x00039B4C
		public void GetTextureInspectionModelImage(HTextureInspectionModel textureInspectionModel)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(2075);
			HalconAPI.Store(proc, 0, textureInspectionModel);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(textureInspectionModel);
		}

		/// <summary>
		///   Guided filtering of an image.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="imageGuide">Guidance image.</param>
		/// <param name="radius">Radius of the filtering operation. Default: 3</param>
		/// <param name="amplitude">Controls the influence of edges on the smoothing. Default: 20.0</param>
		/// <returns>Output image.</returns>
		// Token: 0x06000920 RID: 2336 RVA: 0x0003B9A0 File Offset: 0x00039BA0
		public HImage GuidedFilter(HImage imageGuide, int radius, double amplitude)
		{
			IntPtr proc = HalconAPI.PreCall(2078);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, imageGuide);
			HalconAPI.StoreI(proc, 0, radius);
			HalconAPI.StoreD(proc, 1, amplitude);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(imageGuide);
			return result;
		}

		/// <summary>
		///   Create an interleaved image from a multichannel image.
		///   Instance represents: Input multichannel image.
		/// </summary>
		/// <param name="pixelFormat">Target format for InterleavedImage. Default: "rgba"</param>
		/// <param name="rowBytes">Number of bytes in a row of the output image. Default: "match"</param>
		/// <param name="alpha">Alpha value for three channel input images. Default: 255</param>
		/// <returns>Output interleaved image.</returns>
		// Token: 0x06000921 RID: 2337 RVA: 0x0003BA08 File Offset: 0x00039C08
		public HImage InterleaveChannels(string pixelFormat, HTuple rowBytes, int alpha)
		{
			IntPtr proc = HalconAPI.PreCall(2079);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, pixelFormat);
			HalconAPI.Store(proc, 1, rowBytes);
			HalconAPI.StoreI(proc, 2, alpha);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBytes);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create an interleaved image from a multichannel image.
		///   Instance represents: Input multichannel image.
		/// </summary>
		/// <param name="pixelFormat">Target format for InterleavedImage. Default: "rgba"</param>
		/// <param name="rowBytes">Number of bytes in a row of the output image. Default: "match"</param>
		/// <param name="alpha">Alpha value for three channel input images. Default: 255</param>
		/// <returns>Output interleaved image.</returns>
		// Token: 0x06000922 RID: 2338 RVA: 0x0003BA70 File Offset: 0x00039C70
		public HImage InterleaveChannels(string pixelFormat, string rowBytes, int alpha)
		{
			IntPtr proc = HalconAPI.PreCall(2079);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, pixelFormat);
			HalconAPI.StoreS(proc, 1, rowBytes);
			HalconAPI.StoreI(proc, 2, alpha);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment image using Maximally Stable Extremal Regions (MSER).
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="MSERLight">Segmented light MSERs.</param>
		/// <param name="polarity">The polarity of the returned MSERs. Default: "both"</param>
		/// <param name="minArea">Minimal size of an MSER. Default: 10</param>
		/// <param name="maxArea">Maximal size of an MSER. Default: []</param>
		/// <param name="delta">Amount of thresholds for which a region needs to be stable. Default: 15</param>
		/// <param name="genParamName">List of generic parameter names. Default: []</param>
		/// <param name="genParamValue">List of generic parameter values. Default: []</param>
		/// <returns>Segmented dark MSERs.</returns>
		// Token: 0x06000923 RID: 2339 RVA: 0x0003BAD0 File Offset: 0x00039CD0
		public HRegion SegmentImageMser(out HRegion MSERLight, string polarity, HTuple minArea, HTuple maxArea, HTuple delta, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2087);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, polarity);
			HalconAPI.Store(proc, 1, minArea);
			HalconAPI.Store(proc, 2, maxArea);
			HalconAPI.Store(proc, 3, delta);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minArea);
			HalconAPI.UnpinTuple(maxArea);
			HalconAPI.UnpinTuple(delta);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out MSERLight);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment image using Maximally Stable Extremal Regions (MSER).
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="MSERLight">Segmented light MSERs.</param>
		/// <param name="polarity">The polarity of the returned MSERs. Default: "both"</param>
		/// <param name="minArea">Minimal size of an MSER. Default: 10</param>
		/// <param name="maxArea">Maximal size of an MSER. Default: []</param>
		/// <param name="delta">Amount of thresholds for which a region needs to be stable. Default: 15</param>
		/// <param name="genParamName">List of generic parameter names. Default: []</param>
		/// <param name="genParamValue">List of generic parameter values. Default: []</param>
		/// <returns>Segmented dark MSERs.</returns>
		// Token: 0x06000924 RID: 2340 RVA: 0x0003BB80 File Offset: 0x00039D80
		public HRegion SegmentImageMser(out HRegion MSERLight, string polarity, int minArea, int maxArea, int delta, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2087);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, polarity);
			HalconAPI.StoreI(proc, 1, minArea);
			HalconAPI.StoreI(proc, 2, maxArea);
			HalconAPI.StoreI(proc, 3, delta);
			HalconAPI.Store(proc, 4, genParamName);
			HalconAPI.Store(proc, 5, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HRegion.LoadNew(proc, 2, num, out MSERLight);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Train a texture inspection model.</summary>
		/// <param name="textureInspectionModel">Handle of the texture inspection model.</param>
		// Token: 0x06000925 RID: 2341 RVA: 0x0003BC1C File Offset: 0x00039E1C
		public static void TrainTextureInspectionModel(HTextureInspectionModel textureInspectionModel)
		{
			IntPtr proc = HalconAPI.PreCall(2099);
			HalconAPI.Store(proc, 0, textureInspectionModel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(textureInspectionModel);
		}

		/// <summary>
		///   Reconstruct a surface from several, differently illuminated images.
		///   Instance represents: The Images.
		/// </summary>
		/// <param name="gradient">The Gradient.</param>
		/// <param name="albedo">The Albedo.</param>
		/// <param name="resultType">The Result type. Default: "all"</param>
		/// <returns>The NormalField.</returns>
		// Token: 0x06000926 RID: 2342 RVA: 0x0003BC50 File Offset: 0x00039E50
		public HImage UncalibratedPhotometricStereo(out HImage gradient, out HImage albedo, HTuple resultType)
		{
			IntPtr proc = HalconAPI.PreCall(2101);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, resultType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(resultType);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out gradient);
			num = HImage.LoadNew(proc, 3, num, out albedo);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Insert objects into an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="objectsInsert">Object tuple to insert.</param>
		/// <param name="index">Index to insert objects.</param>
		/// <returns>Extended object tuple.</returns>
		// Token: 0x06000927 RID: 2343 RVA: 0x0003BCCC File Offset: 0x00039ECC
		public HImage InsertObj(HImage objectsInsert, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2121);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsInsert);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsInsert);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06000928 RID: 2344 RVA: 0x0003BD2C File Offset: 0x00039F2C
		public new HImage RemoveObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06000929 RID: 2345 RVA: 0x0003BD84 File Offset: 0x00039F84
		public new HImage RemoveObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x0600092A RID: 2346 RVA: 0x0003BDD4 File Offset: 0x00039FD4
		public HImage ReplaceObj(HImage objectsReplace, HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x0600092B RID: 2347 RVA: 0x0003BE38 File Offset: 0x0003A038
		public HImage ReplaceObj(HImage objectsReplace, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>Get the clutter parameters of a shape model.</summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="genParamName">Parameter names. Default: "use_clutter"</param>
		/// <param name="genParamValue">Parameter values.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images.</param>
		/// <returns>Region where no clutter should occur.</returns>
		// Token: 0x0600092C RID: 2348 RVA: 0x0003BE98 File Offset: 0x0003A098
		public static HRegion GetShapeModelClutter(HShapeModel modelID, HTuple genParamName, out HTuple genParamValue, out HHomMat2D homMat2D, out int clutterContrast)
		{
			IntPtr proc = HalconAPI.PreCall(2178);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, num, out genParamValue);
			num = HHomMat2D.LoadNew(proc, 1, num, out homMat2D);
			num = HalconAPI.LoadI(proc, 2, num, out clutterContrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary>Get the clutter parameters of a shape model.</summary>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="genParamName">Parameter names. Default: "use_clutter"</param>
		/// <param name="genParamValue">Parameter values.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images.</param>
		/// <returns>Region where no clutter should occur.</returns>
		// Token: 0x0600092D RID: 2349 RVA: 0x0003BF24 File Offset: 0x0003A124
		public static HRegion GetShapeModelClutter(HShapeModel modelID, string genParamName, out string genParamValue, out HHomMat2D homMat2D, out int clutterContrast)
		{
			IntPtr proc = HalconAPI.PreCall(2178);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			num = HalconAPI.LoadS(proc, 0, num, out genParamValue);
			num = HHomMat2D.LoadNew(proc, 1, num, out homMat2D);
			num = HalconAPI.LoadI(proc, 2, num, out clutterContrast);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(modelID);
			return result;
		}

		/// <summary> Set the clutter parameters of a shape model.</summary>
		/// <param name="clutterRegion">Region where no clutter should occur.</param>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images. Default: 128</param>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x0600092E RID: 2350 RVA: 0x0003BFAC File Offset: 0x0003A1AC
		public static void SetShapeModelClutter(HRegion clutterRegion, HShapeModel modelID, HHomMat2D homMat2D, int clutterContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2180);
			HalconAPI.Store(proc, 1, clutterRegion);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreI(proc, 2, clutterContrast);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(clutterRegion);
			GC.KeepAlive(modelID);
		}

		/// <summary> Set the clutter parameters of a shape model.</summary>
		/// <param name="clutterRegion">Region where no clutter should occur.</param>
		/// <param name="modelID">Handle of the model.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="clutterContrast">Minimum contrast of clutter in the search images. Default: 128</param>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x0600092F RID: 2351 RVA: 0x0003C02C File Offset: 0x0003A22C
		public static void SetShapeModelClutter(HRegion clutterRegion, HShapeModel modelID, HHomMat2D homMat2D, int clutterContrast, string genParamName, double genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2180);
			HalconAPI.Store(proc, 1, clutterRegion);
			HalconAPI.Store(proc, 0, modelID);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreI(proc, 2, clutterContrast);
			HalconAPI.StoreS(proc, 3, genParamName);
			HalconAPI.StoreD(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(clutterRegion);
			GC.KeepAlive(modelID);
		}

		/// <summary>Read metadata from image files.</summary>
		/// <param name="format">Graphic format. Default: "tiff"</param>
		/// <param name="tagName">Name of the tag to be written in the image file. Default: "tiff_image_description"</param>
		/// <param name="fileName">Name of image file.</param>
		/// <returns>Output tag value read from the image file.</returns>
		// Token: 0x06000930 RID: 2352 RVA: 0x0003C0A0 File Offset: 0x0003A2A0
		public static HTuple ReadImageMetadata(string format, HTuple tagName, string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(2185);
			HalconAPI.StoreS(proc, 0, format);
			HalconAPI.Store(proc, 1, tagName);
			HalconAPI.StoreS(proc, 2, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(tagName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>
		///   Extract watersheds and combine basins based on markers.
		///   Instance represents: Input image.
		/// </summary>
		/// <param name="markers">Initial markers from which to flood the image.</param>
		/// <returns>Basins for all markers.</returns>
		// Token: 0x06000931 RID: 2353 RVA: 0x0003C0F8 File Offset: 0x0003A2F8
		public HRegion WatershedsMarker(HRegion markers)
		{
			IntPtr proc = HalconAPI.PreCall(2190);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, markers);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(markers);
			return result;
		}

		/// <summary>Write metadata of image files.</summary>
		/// <param name="format">Graphic format. Default: "tiff"</param>
		/// <param name="tagName">Name of the tag to be written in the image file. Default: "tiff_image_description"</param>
		/// <param name="tagValue">Value of the tag to be written in the image file.</param>
		/// <param name="fileName">Name of image file.</param>
		// Token: 0x06000932 RID: 2354 RVA: 0x0003C150 File Offset: 0x0003A350
		public static void WriteImageMetadata(string format, HTuple tagName, HTuple tagValue, string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(2191);
			HalconAPI.StoreS(proc, 0, format);
			HalconAPI.Store(proc, 1, tagName);
			HalconAPI.Store(proc, 2, tagValue);
			HalconAPI.StoreS(proc, 3, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(tagName);
			HalconAPI.UnpinTuple(tagValue);
			HalconAPI.PostCall(proc, procResult);
		}
	}
}
